Solving robust MDPs as a sequence of static RL problems

## Abstract

Abstract Designing control policies whose performance level is guaranteed to remain above a given threshold in a span of environments is a critical feature for the adoption of reinforcement learning (RL) in real-world applications.
The search for such robust policies is a notoriously difficult problem, related to the so-called dynamic model of transition function uncertainty, where the environment dynamics are allowed to change at each time step.
But in practical cases, one is rather interested in robustness to a span of static transition models throughout interaction episodes.
The static model is known to be harder to solve than the dynamic one, and seminal algorithms, such as robust value iteration, as well as most recent works on deep robust RL, build upon the dynamic model.
In this work, we propose to revisit the static model.
We suggest an analysis of why solving the static model under some mild hypotheses is a reasonable endeavor, based on an equivalence with the dynamic model, and formalize the general intuition that robust MDPs can be solved by tackling a series of static problems.
We introduce a generic meta-algorithm called IWOCS, which incrementally identifies worst-case transition models so as to guide the search for a robust policy.
Discussion on IWOCS sheds light on new ways to decouple policy optimization and adversarial transition functions and opens new perspectives for analysis.
We derive a deep RL version of IWOCS and demonstrate it is competitive with state-of-the-art algorithms on classical benchmarks.

## 1 Introduction

One major obstacle in the way of real-life deployment of reinforcement learning (RL) algorithms is their inability to produce policies that retain, without further training, a guaranteed level of efficiency when controlling a system that somehow differs from the one they were trained upon.
This property is referred to as *robustness*, by opposition to *resilience*, which is the ability to recover, through continued learning, from environmental changes.
For example, when learning control policies for aircraft stabilization using a simulator, it is crucial that the learned controller be able to control a span of aircraft configurations with different geometries, or masses, or in various atmospheric conditions.
Depending on the criticality of the considered application, one will prefer to optimize the expected performance over a set of environments (thus weighting in the probability of occurrence of a given configuration) or, at the extreme, optimize for the worst case configuration.
Here, we consider such worst case guarantees and revisit the framework of robust Markov Decision Processes (MDPs) (Iyengar, ).

Departing from the common perspective which views robust MDPs as two-player games, we investigate whether it is possible to solve them through a series of non-robust problems.
The two-player game formulation is called the dynamic model of transition function uncertainty, as an adversarial environment is allowed to change the transition dynamics at each time step.
The solution to this game can be shown to be equivalent, for stationary policies and rectangular uncertainty sets, to that of the static model, where the environment retains the same transition function throughout the time steps.

Our first contribution is a series of arguments which cast the search for a robust policy as a resolution of the static model (Section 2).
We put this formulation in perspective of recent related works in robust RL (Section 3).
Then, we introduce a generic meta-algorithm which we call IWOCS for Incremental Worst-Case Search (Section 4).
IWOCS builds upon the idea of incrementally identifying worst case transition functions and expanding a discrete uncertainty set, for which a robust policy can be approximated through a finite set of non-robust value functions.
We instantiate two IWOCS algorithms, one on a toy illustrative problem with a discrete state space, then another on popular, continuous states and actions, robust RL benchmarks where it is shown to be competitive with state-of-the art robust deep RL algorithms (Section 5).

## 2 Problem statement

#### Reinforcement Learning

(RL) (Sutton and Barto, ) considers the problem of learning a decision making policy for an agent interacting over multiple time steps with a dynamic environment.
At each time step, the agent and environment are described through a state $s\in\mathcal{S}$, and an action $a\in\mathcal{A}$ is performed; then the system transitions to a new state $s^{\prime}$ according to probability $T(s^{\prime}|s,a)$, while receiving reward $r(s,a,s^{\prime})$.

The tuple $M_{T}=(\mathcal{S},\mathcal{A},T,r)$ forms a Markov Decision Process (MDP) (Puterman, ), which is often complemented with the knowledge of an initial state distribution $p_{0}(s)$.
Without loss of generality and for the sake of readability, we will consider a unique starting state $s_{0}$ in this paper, but our results extend straightforwardly to a distribution $p_{0}(s)$.
A stationary decision making policy is a function $\pi(a|s)$ mapping states to distributions over actions (writing $\pi(s)$ the action for the special case of deterministic policies).

Training a reinforcement learning agent in MDP $M_{T}$ consists in finding a policy that maximizes the expected $\gamma$-discounted return from $s_{0}$: $J^{\pi}_{T}=\mathbb{E}[\sum_{t=0}^{\infty}\gamma^{t}r(s_{t},a_{t},s_{t+1})|s_{
0},a_{t}\sim\pi,s_{t+1}\sim T]=V^{\pi}_{T}(s_{0})$,

where $V^{\pi}_{T}$ is the value function of $\pi$ in MDP $M_{T}$, and $\gamma\in[0,1)$.
An optimal policy in $M_{T}$ will be noted $\pi^{*}_{T}$ and its value function $V^{*}_{T}$.
A convenient notation is the state-action value function $Q^{\pi}_{T}(s,a)=\mathbb{E}_{s^{\prime}\sim T}[r(s,a,s^{\prime})+\gamma V^{\pi
}_{T}(s^{\prime})]$ of policy $\pi$ in MDP $M_{T}$, and the corresponding optimal $Q^{*}_{T}$. Key notations are summarized in Appendix C.

#### Robust MDPs,

as introduced by Iyengar () or Nilim and El Ghaoui (), introduce an additional challenge.
The transition functions $T$ are picked from an uncertainty set $\mathcal{T}$ and are allowed to change at each time step, yielding a sequence $\mathbf{T}=\{T_{t}\}_{t\in\mathbb{N}}$.
A common assumption, called *$sa$-rectangularity*, states that $\mathcal{T}$ is a Cartesian product of independent marginal sets of distributions on $\mathcal{S}$, for each state-action pair.
The value of a stationary policy $\pi$ in the sequence of MDPs induced by $\mathbf{T}=\{T_{t}\}_{t\in\mathbb{N}}$ is noted $V^{\pi}_{\mathbf{T}}$.
The pessimistic value function for $\pi$ is $V^{\pi}_{\mathcal{T}}(s)=\min_{\mathbf{T}}V^{\pi}_{\mathbf{T}}(s)$, where the agent plays a sequence of actions $a_{t}\in\mathcal{A}$ drawn from $\pi$, against the environment, which in turn picks transition models $T_{t}\in\mathcal{T}$ so as to minimize the overall return.
The robust value function is the largest such pessimistic value function and hence the solution to $V^{*}_{\mathcal{T}}(s)=\max_{\pi}\min_{\mathbf{T}}V^{\pi}_{\mathbf{T}}(s)$.
The robust MDP problem can be cast as the zero-sum two-player game, where $\hat{\pi}$ denote the decision making policy of the adversarial environment, deciding $T_{t}\in\mathcal{T}$ based on previous observations.
Then, the problem becomes $\max_{\pi}\min_{\hat{\pi}}V^{\pi}_{\hat{\pi}}(s)$, where $V^{\pi}_{\hat{\pi}}$ is the expected value of a trajectory where policies $\pi$ and $\hat{\pi}$ play against each other.
Hence, the optimal policy becomes the minimax policy, which makes it robust to all possible future evolutions of the environment’s properties.

#### Robust Value Iteration.

Following Iyengar (, Theorem 3.2), the optimal robust value function $V^{*}_{\mathcal{T}}(s)=\max_{\pi}\min_{\mathbf{T}}V^{\pi}_{\mathbf{T}}(s)$ is the unique solution to the robust Bellman equation $V(s)=\max_{a}\min_{T}\mathbb{E}_{s^{\prime}\sim T}[r(s,a,s^{\prime})+\gamma V(
s^{\prime})]=\mathcal{L}V(s)$.
This directly translates into a robust value iteration algorithm which constructs the $V_{n+1}=\mathcal{L}V_{n}$ sequence of value functions (Satia and Lave Jr, ; Iyengar, ).
Such robust policies are, by design, very conservative, in particular when the uncertainty set is large and under the rectangularity assumption. Several attempts at mitigating this intrinsic over-conservativeness have been made from various perspectives. For instance, Lim et al. () propose to learn and tighten the uncertainty set, echoing other works that incorporate knowledge about this set into the minimax resolution (Xu and Mannor, ; Mannor et al., ).
Other approaches (Wiesemann et al., ; Lecarpentier and Rachelson, ; Goyal and Grand-Clement, ) propose to lift the rectangularity assumption and capture correlations in uncertainties across states or time steps, yielding significantly less conservative policies.
Ho et al. () and Grand-Clément and Kroer () retain the rectangularity assumption and propose algorithmic schemes to tackle large but discrete state and action spaces.

#### The static model.

In many applications, one does not wish to consider non-stationary transition functions, but rather to be robust to any transition function from $\mathcal{T}$ which remains stationary throughout a trajectory.
This is called the *static* model of transition function uncertainty, by opposition to the *dynamic* model where transition functions can change at each time step.
Hence, the static model’s minimax game boils down to $\max_{\pi}\min_{T}V^{\pi}_{T}(s)$.
If the agent is restricted to stationary policies $\pi(a|s)$, then $\max_{\pi}\min_{\mathbf{T}}V^{\pi}_{\mathbf{T}}(s)=\max_{\pi}\min_{T}V^{\pi}_{
T}(s)$ (Iyengar, , Lemma 3.3), that is the static and dynamic problems are equivalent, and the solution to the dynamic problem is found for a static adversary.(^1^11This does not imply the solution to the static model is the same as that of the dynamic model in general: the optimal static $\pi$ may be non-stationary and finding it is known to be NP-hard.)
In this paper, we will only consider stationary policies.

#### No-duality gap.

Wiesemann et al. (, Equation 4 and Proposition 9) introduce an important saddle point condition stating that $\max_{\pi}\min_{T}V^{\pi}_{T}(s)=\min_{T}\max_{\pi}V^{\pi}_{T}(s)$. (^2^22The static-dynamic equivalence and the no-duality gap property’s context is recalled in Appendix B.)

#### Incrementally solving the static model.

Combining the static and dynamic models equivalence and the no-duality gap condition, we obtain that, for rectangular uncertainty sets and stationary policies, the optimal robust value function $V^{*}_{\mathcal{T}}(s)=\max_{\pi}\min_{\mathbf{T}}V^{\pi}_{\mathbf{T}}(s)=\max
_{\pi}\min_{T}V^{\pi}_{T}(s)=\min_{T}\max_{\pi}V^{\pi}_{T}(s)=\min_{T}V^{*}_{T
}(s)$.
The key idea we develop in this paper stems from this formulation.
Suppose we are presented with $M_{T_{0}}$ and solve it to optimality, finding $V^{*}_{0}(s)=V^{*}_{T_{0}}(s)$.
Then, suppose we identify $M_{T_{1}}$ as a possible better estimate of a worst case MDP in $\mathcal{T}$ than $T_{0}$.
We can solve for $V^{*}_{T_{1}}$ and $V^{*}_{1}(s)=\min\{V^{*}_{T_{0}}(s),V^{*}_{T_{1}}(s)\}$ is the robust value function for the discrete uncertainty set $\mathcal{T}_{1}=\{T_{0},T_{1}\}$.
The intuition we attempt to capture is that by incrementally identifying candidate worst case MDPs, one should be able to define a sequence of discrete uncertainty sets $\mathcal{T}_{i}=\{T_{j}\}_{j\in[0,i]}$ whose robust value function $V^{*}_{i}$ decreases monotonously, and may converge to $V^{*}$.
In other words, it should be possible to incrementally robustify a policy by identifying the appropriate sequence of transition models and solving individually for them, trading the complexity of the dynamic model’s resolution for a sequence of classical MDP problems.
The algorithm we propose in Section 4 follows this idea and searches for robust stationary policies for the dynamic model, using the static model, by incrementally growing a finite uncertainty set.

## 3 Related work

#### Robust RL as two-player games.

A common approach to solving robust RL problems is to cast the dynamic formulation as a zero-sum two player game, as formalized by Morimoto and Doya ().
In this framework, an adversary, denoted by $\hat{\pi}:\mathcal{S}\rightarrow\mathcal{T}$, is introduced, and the game is formulated as $\max_{\pi}\min_{\hat{\pi}}\mathbb{E}[\sum_{t=0}^{\infty}\gamma^{t}r(s_{t},a_{t
},s_{t+1})|s_{0},a_{t}\sim\pi(\cdot|s_{t}),T_{t}=\hat{\pi}(s_{t},a_{t}),s_{t+1
}\sim T_{t}(\cdot|s_{t},a_{t})]$.
Most methods differ in how they constrain $\hat{\pi}$’s action space within the uncertainty set.
A first family of methods define $\hat{\pi}(s_{t})=T_{ref}+\Delta(s_{t})$, where $T_{ref}$ denotes the reference transition function.
Among this family, Robust Adversarial Reinforcement Learning (RARL) (Pinto et al., ) applies external forces at each time step $t$ to disturb the reference dynamics.
For instance, the agent controls a planar monopod robot, while the adversary applies a 2D force on the foot.
In noisy action robust MDPs (NR-MDP) (Tessler et al., ) the adversary shares the same action space as the agent and disturbs the agent’s action $\pi(s)$.
Such gradient-based approaches incur the risk of finding stationary points for $\pi$ and $\hat{\pi}$ which do not correspond to saddle points of the robust MDP problem.
To prevent this, Mixed-NE (Kamalaruban et al., ) defines mixed strategies and uses stochastic gradient Langevin dynamics.
Similarly, Robustness via Adversary Populations (RAP) (Vinitsky et al., ) introduces a population of adversaries, compelling the agent to exhibit robustness against a diverse range of potential perturbations rather than a single one, which also helps prevent finding stationary points that are not saddle points.
Aside from this first family, State Adversarial MDPs (Zhang et al., , ; Stanton et al., ) involve adversarial attacks on state observations, which implicitly define a partially observable MDP.
The goal in this case is not to address robustness to the worst-case transition function but rather against noisy, adversarial observations.
A third family of methods considers the general case of $\hat{\pi}(s_{t})=T_{t}$ where $T_{t}\in\mathcal{T}$.
Minimax Multi-Agent Deep Deterministic Policy Gradient (M3DDPG) (Li et al., ) is designed to enhance robustness in multi-agent reinforcement learning settings, but boils down to standard robust RL in the two-agents case.
Max-min TD3 (M2TD3) (Tanabe et al., ) considers a policy $\pi$, defines a value function $Q(s,a,T)$ which approximates $Q^{\pi}_{T}(s,a)=\mathbb{E}_{s^{\prime}\sim T}[r(s,a,s^{\prime})+\gamma V^{\pi
}_{T}(s^{\prime})]$, updates an adversary $\hat{\pi}$ so as to minimize $Q(s,\pi(s),\hat{\pi}(s))$ by taking a gradient step with respect to $\hat{\pi}$’s parameters, and updates the policy $\pi$ using a TD3 gradient update in the direction maximizing $Q(s,\pi(s),\hat{\pi}(s))$.
As such, M2TD3 remains a robust value iteration method which solves the dynamic problem by alternating updates on $\pi$ and $\hat{\pi}$, but since it approximates $Q^{\pi}_{T}$, it is also closely related to the method we introduce in the next section.
Wang et al. () introduced a policy gradient method for robust MDPs with global convergence guarantees. While their work shares some conceptual similarities with ours in optimizing policies using a static model, it differs in key aspects. Their approach is limited to policy-based methods, whereas ours is more versatile, applicable to any RL algorithm, and scalable to larger state and action spaces.

#### Regularization.

Derman et al. (); Eysenbach and Levine () also highlighted the strong link between robust MDPs and regularized MDPs, showing that a regularized policy learned during interaction with a given MDP was actually robust to an uncertainty set around this MDP.
Kumar et al. () propose a promising approach in which they derive the adversarial transition function in a closed form and demonstrate that it is a rank-one perturbation of the reference transition function.
This simplification results in more streamlined computation for the robust policy gradient.

#### Domain randomization

(DR) (Tobin et al., ) learns a value function
$V(s)=\max_{\pi}\mathbb{E}_{T\sim\mathcal{U}(\mathcal{T})}V_{T}^{\pi}(s)$ which maximizes the expected return *on average* across a fixed distribution on $\mathcal{T}$.
As such, DR approaches do not optimize the worst-case performance.
Nonetheless, DR has been used convincingly in applications (Mehta et al., ; OpenAI et al., ).
Similar approaches also aim to refine a base DR policy for application to a sequence of real-world cases (Lin et al., ; Dennis et al., ; Yu et al., ).

For a more complete survey of recent works in robust RL, we refer the reader to the work of Moos et al. ().
To the best of our knowledge, the approach sketched in the previous section and developed in the next one is the only one that directly addresses the static model.
For that purpose, it exploits the equivalence with the dynamic model for stationary policies and solves the dual of the minimax problem, owing to the no-duality gap property.

## 4 Incremental Worst-case Search

In order to search for robust policies, we consider the no-duality gap property: the best performance one can expect in the face of transition function uncertainty $\max_{\pi}\min_{T}V^{\pi}_{T}(s_{0})$,
is also the worst performance the environment can induce for each transition function’s optimal policy $\min_{T}V^{*}_{T}(s_{0})$.
If the value $V^{\pi}_{T}(s_{0})$ was strictly concave/convex with respect to $\pi$/$T$ respectively, we could hope to solve for the robust policy through a (sub)gradient ascent/descent method.
Unfortunately, it seems $V^{\pi}_{T}(s_{0})$ easily admits more convoluted optimization landscapes, involving stationary points, local minima and maxima.
The $\max_{\pi}$ problem often benefits from regularization (Geist et al., ).
Although one could study regularization for the $\min_{T}$ problem (Grand-Clément and Petrik, ) or the equivalence with a regularized objective (Derman et al., ), we turn towards a simpler process conceptually.

#### Algorithm.

We consider a (small) discrete set of MDPs $\mathcal{T}_{i}=\{T_{j}\}_{j\in[0,i]}$, for which we derive the corresponding optimal value functions $Q^{*}_{T_{j}}$.
Then we define $Q_{i}$ as the function that maps any pair $s,a$ to the smallest expected optimal outcome $Q_{i}(s,a)=\min_{j\in[0,i]}\{Q^{*}_{T_{j}}(s,a)\}$.
The corresponding greedy policy is $\pi_{i}(s)\in\arg\max_{a}Q_{i}(s,a)$ and is a candidate for the robust policy.
Let us define $T_{i+1}\in\arg\min_{T\in\mathcal{T}}V^{\pi_{i}}_{T}(s_{0})$.
Then, if $V^{\pi_{i}}_{T_{i+1}}(s_{0})=Q_{i}(s_{0},\pi_{i}(s_{0}))$, we have found a robust policy for all transition models in $\mathcal{T}$.
Otherwise, we can solve for $Q^{*}_{T_{i+1}}$, append $T_{i+1}$ to $\mathcal{T}_{i}$ to form $\mathcal{T}_{i+1}$, and repeat.
Consequently, the idea we develop is to incrementally expand $\mathcal{T}_{i}$ by solving $\min_{T\in\mathcal{T}}V^{\pi_{i}}_{T}(s_{0})$ using optimization methods that can cope with ill-conditioned optimization landscapes.
We call Incremental Worst Case Search (IWOCS) this general method, which we summarize in Algorithm 1.

Figure: Algorithm 1 Incremental Worst-Case Search meta-algorithm (in blue: the sub-algorithms)

#### Rectangularity.

One should note that $\mathcal{T}_{i}$ is a subset of a (supposed) $sa$-rectangular uncertainty set, but is not $sa$-rectangular itself, so there is no guarantee that the static-dynamic equivalence holds in $\mathcal{T}_{i}$, and $Q_{i}$ is a pessimistic value function for the static case only, on the $\mathcal{T}_{i}$ uncertainty set.
However, one can consider the $sa$-rectangular set $\tilde{\mathcal{T}}_{i}=\bigtimes_{s,a}\{T_{j}(\cdot|s,a)\}_{j\in[0,i]}$ composed of the cartesian product of all local $\{T_{j}(\cdot|s,a)\}_{j\in[0,i]}$ sets for each $s,a$ pair.

###### Property 1 .

For any $i,s,a$, we have

$$ $Q_{i}(s,a)\geq Q^{*}_{\tilde{\mathcal{T}}_{i}}(s,a)\geq Q^{*}_{\mathcal{T}}(s, a).$ $$

The proof follows directly from the fact that $\mathcal{T}_{i}\subset\tilde{\mathcal{T}}_{i}\subset\mathcal{T}$.

We abusively call $Q_{i}$ the $\mathcal{T}_{i}$-robust value function.
In $s_{0}$, $Q_{i}$ coincides with the robust value function for the static model of uncertainty with respect to the $\mathcal{T}_{i}$ uncertainty set.

###### Property 2 .

For any $i,s,a$, we have

$$ $Q_{i+1}(s,a)\leq Q_{i}(s,a).$ $$

The proof is immediate as well since $Q_{i+1}$ drawn among the same finite set of functions as $Q_{i}$, complemented with $Q^{*}_{T_{i+1}}$.
Hence the $Q_{i}$ functions form a monotonically decreasing sequence.
Since $Q_{i}$ is lower bounded (by $Q^{*}_{\mathcal{T}}$), IWOCS is necessarily convergent.(^3^33Although not necessarily to $Q^{*}_{\mathcal{T}}$.)

###### Property 1 .

###### Property 2 .

#### Choosing T i + 1 subscript 𝑇 𝑖 1 T_{i+1} italic_T start_POSTSUBSCRIPT italic_i + 1 end_POSTSUBSCRIPT .

One could define a variant of Algorithm 1 which picks $T_{i+1}$ using another criterion than the worst-case transition model for $\pi_{i}$, for instance by drawing $T_{i+1}$ uniformly at random, without loosing the two properties above.
This underlines that the procedure for choosing $T_{i+1}$ is a heuristic part of IWOCS.
In all cases, the sequence of $Q_{i}$ remains monotonous and hence convergence in the limit remains guaranteed.
Specifically, if, in the limit, $\mathcal{T}_{i}$ converges to $\mathcal{T}$ (under some appropriate measure on uncertainty sets), then $Q_{i}$ converges to the robust value function by definition.
Whether this occurs or not, strongly depends on how $T_{i+1}$ is chosen at each iteration.
In particular, premature stopping can occur if $T_{i+1}$ is among $\mathcal{T}_{i}$.
We conjecture choosing the worst-case transition model for $\pi_{i}$ is an intuitive choice here, and reserve further theoretical analysis on this matter for future work.
One bottleneck difficulty of this selection procedure for $T_{i+1}$ lies in solving the $\min_{T}$ problem accurately enough. However this difficulty is decoupled from that of the policy optimization process, which is only concerned with static MDPs.

Figure: Figure 1: Convergence to $V^{*}$ vs Bellman iterates (right) in the Windy walk grid-world (left).
Refer to caption: extracted/5910764/medias/toy_env_viz.png

#### Illustration.

We implement an IWOCS algorithm on a toy example, using value iteration (VI) as the policy optimization algorithm and a brute force search across transition functions to identify worst-case MDPs ($V^{\pi_{i}}_{T}(s_{0})$ is evaluated through Monte-Carlo rollouts).
Detailed pseudo-code is provided in Appendix E.
The goal here is to illustrate the behavior of IWOCS, compare it to the seminal robust value iteration (RVI) algorithm, and validate empirically that IWOCS is able to find worst-case static MDPs and robust policies.
This vanilla IWOCS is evaluated on the “windy walk” grid-world MDP illustrated on Figure 1, where an agent wishes to navigate from a starting position $S$ to a goal $G$.
Actions belong to the discrete $\{N,S,E,W\}$ set and transitions are deterministic, except in the “corridors”, where wind can knock back the agent to the left.
In the topmost corridor, the probability of being knocked left is $\alpha$, in the middle corridor it is $\alpha^{3}$ and it is $\alpha^{6}$ in the bottom corridor. Hence, the uncertainty set is fully parameterized by $\alpha$, which takes 25 discrete values, uniformly distributed in $[0,0.5]$.
Rewards are $-1$ at each time step and the goal is an absorbing state yielding zero reward.

Figure 1 illustrates how IWOCS converges to the robust value function $V^{*}$.
RVI builds the sequence $V_{n+1}=\mathcal{L}V_{n}$ and we plot $|V_{n}(s_{0})-V^{*}_{\mathcal{T}}(s_{0})|$ versus the number of robust Bellman iterates $n$.
On the other hand, IWOCS requires its first policy optimization to terminate before it can report its first $Q_{i}(s_{0},\pi_{i}(s_{0}))$.
Thus, we plot $|Q_{i}(s_{0},\pi_{i}(s_{0}))-V^{*}_{\mathcal{T}}(s_{0})|$ after a fixed number of 100 standard Bellman backups for VI.
It is important to note that one iterate of the standard Bellman operator requires solving a $\max_{a}$ in each state, while an iterate of the robust Bellman operator requires solving a more costly $\max_{a}\min_{T}$ problem in each state.
Therefore, the x-axis does not account for computational time.
IWOCS finds the worst-case static model after two iterations and converges to the same value as RVI.

#### Computational complexity.

Recall that the complexity of robust value iteration (RVI), in discrete state and action MDPs, and for a $sa$-rectangular uncertainty set, is $O(cn_{S}^{2}n_{A}\log(1/\epsilon)/\log(1-\gamma))$, where $n_{S}$ is the number of states, $n_{A}$ the number of actions, $\epsilon$ is the tolerance for the robust value function and $c$ is the cost of computing a single $\min_{T}$ solution (Iyengar, ).
Recall also that the complexity of value iteration (VI) is $O(n_{S}^{2}n_{A}\log(1/\epsilon)/\log(1-\gamma))$ (VI is a special case of RVI with a singleton as uncertainty set, so $c=1$).
Comparing IWOCS and RVI is a delicate matter because IWOCS is not based on a contraction mapping and has no convergence guarantees to the robust value function.
Consequently, comparisons should be taken with a grain of salt.
Yet, it is legitimate to wonder whether one can analyse the time complexity of IWOCS versus RVI.
One iteration of IWOCS in discrete state and action spaces, as presented in Section 4, has the complexity of VI for the policy search part, plus the complexity of finding a worst case transition function in an $sa$-rectangular uncertainty set, which is $O(cn_{S}n_{A})$.
Hence, the overall complexity for $M$ iterations of IWOCS is $O(M(n_{S}^{2}n_{A}\log(1/\epsilon)/\log(1-\gamma)+cn_{S}n_{A}))$.
Compared to RVI, this bound will be smaller when $c$ is large, which is the case when one deals with complex uncertainty sets and without further hypotheses.
This short discussion provides a rationale to why IWOCS might be a time-efficient algorithm in large scale robust RL problems.

## 5 Deep IWOCS

We now turn towards challenging robust control problems and introduce an instance of IWOCS meant to accommodate large and continuous state and action spaces, using function approximators such as neural networks.
This instance of IWOCS uses Soft Actor Critic (SAC) Haarnoja et al. () as the policy optimization method, as it has been proven to yield a locally robust policy around the MDP it is trained upon (Eysenbach and Levine, ).
Appendix D summarizes our experimental computing setup.

### 5.1 Method

#### Accounting for regularization terms.

Since SAC learns a regularized Q-function which accounts for the policy’s entropy, and lets the importance of this term vary along the optimization, orders of magnitude may change between $Q_{T_{i}}$ and $Q_{T_{j}}$.
To avoid the influence of this regularization term when defining the $\mathcal{T}_{i}$-robust Q-function, we train an additional unregularized Q-network which only takes rewards into account.
We call $\pi_{T}$ the policy network which approximates the optimal policy of the regularized MDP based on $T$.
This policy’s (regularized) value function is approximated by the $Q^{\prime}_{T}$ network (our implementation uses double Q-networks as per the common practice — all details in Appendix F), while an additional $Q_{T}$ network (double Q-network also) tracks the unregularized value function of $\pi_{T}$.
The $\mathcal{T}_{i}$-robust Q-function is defined with respect to this unregularized value function as $Q_{i}(s,a)=\min_{j\in[0,i]}\{Q_{T_{j}}(s,a)\}$.

#### Partial state space coverage.

In large state space MDPs, it is likely that interactions will not explore the full state space.
Consequently, the different $Q_{T_{j}}$ functions are trained on replay buffers whose empirical distribution’s support my vary greatly.
Evaluating neural networks outside of their training distribution is prone to generalization errors.
This begs for indicator functions specifying on which $(s,a)$ pair each $Q_{T}$ is relevant.
We chose to implement such an indicator function using predictive coding (Rao and Ballard, ) on the dynamical model $T_{j}$.
Note that other choices can be equally good (or better), such as variance networks (Neklyudov et al., ), ensembles of neural networks (Lakshminarayanan et al., ) or 1-class classification (Béthune et al., ).
Our predictive coding model for $T_{j}$ predicts $\hat{T}_{j}(s,a)=s^{\prime}$ for deterministic dynamics, by minimizing the expected value of the loss $\ell(\hat{T}_{j}(s,a);s^{\prime})=\|\hat{T}_{j}(s,a)-s^{\prime}\|_{1}$.
At inference time, along a trajectory, we consider $Q_{T_{j}}$ has been trained on sufficient data in $s_{t},a_{t}$, if $\ell(\hat{T}_{j}(s_{t-1},a_{t-1});s_{t})\leq\rho_{j}$, ie. if the prediction error for $s_{t}$ is below the threshold $\rho_{j}$ (details about tuning $\rho_{j}$
in Appendix G).
We set $Q^{*}_{T_{j}}$ to be $+\infty$ in all states where $\ell(\hat{T}_{j}(s_{t-1},a_{t-1});s_{t})>\rho_{j}$, so that it does not participate in the definition of $Q_{i}$.

#### Worst case identification.

When $V_{T}^{\pi_{i}}(s_{0})$ is non differentiable with respect to $T$ (or $T$’s parameters), one needs to fall back on black-box optimization to find $T_{i+1}=\arg\min_{T\in\mathcal{T}}V^{\pi_{i}}_{T}(s_{0})$.
We turn to evolutionary strategies, and in particular CMA-ES (Hansen and Ostermeier, ) for that purpose, for its ability to escape local minima and efficiently explore the uncertainty set $\mathcal{T}$ even when the latter is high-dimensional (hyperparameters in Appendix F).
Note that making $V_{T}^{\pi}(s_{0})$ differentiable with respect to $T$ is feasible by making the critic network explicitly depend on $T$’s parameters, as in the work of Tanabe et al. ().
We do not resort to such a model, as it induces the risk for generalization errors, but it constitutes a promising alternative for research.
To evaluate $V_{T}^{\pi_{i}}(s_{0})$ for a given $T$, we run a roll-out from $s_{0}$ by applying $\pi_{i}(s)$ in each encountered state $s$.
Since we consider continuous action spaces and keep track of the critics $Q_{T_{j}}$, $Q^{\prime}_{T_{j}}$ and the actor $\pi_{T_{j}}$ for all $T_{j}\in\mathcal{T}_{i}$, we can make direct use of $\pi_{T_{j}}$ which is designed to mimic an optimal policy in $M_{T_{j}}$.
Specifically, in $s$, we evaluate $j^{*}=\arg\min_{j\leq i}Q^{*}_{T_{j}}(s,\pi_{T_{j}}(s))$, and apply $\pi_{i}(s)=\pi_{j^{*}}(s)$.
If no $Q^{*}_{T_{j}}$ is valid in $s$, we fall back to a default policy trained with domain randomization.

### 5.2 Empirical evaluation

#### Experimental framework.

This section assesses the proposed algorithm’s worst-case performance and generalization capabilities.
Experimental validation is performed on optimal control problems using the MuJoCo simulation environments(^4^44Note that these do not respect the rectangularity assumption.) (Todorov et al., ).
IWOCS is benchmarked against state-of-the-art robust reinforcement learning methods, including M2TD3 (Tanabe et al., ), M3DDPG (Li et al., ), and RARL (Pinto et al., ).
We also compare with Domain Randomization (DR) (Tobin et al., ) for completeness.

For each environment, two versions of the uncertainty set are considered, following the benchmarks reported by Tanabe et al. ().
In the first one, $T$ is parameterized by a global friction coefficient and the agent’s mass
In the second one, a third, environment-dependent parameter is included (details in Appendix J).
To ensure a fair comparison we also aligned with the sample budget of Tanabe et al. (): performance metrics were collected after 4 million steps for environments with a 2D uncertainty set and after 5 million steps for those with a 3D uncertainty set.
All reference methods optimize a single policy along these 4 or 5 million steps, but IWOCS optimizes a sequence of non-robust policies, for which we divide this sample budget: we constrain IWOCS to train its default policy and each subsequent SAC agent for a fixed number of interaction steps, so that the sum is 4 or 5 million steps (Appendix H and I).(^5^55Additional experiments allowing more samples to SAC at each iteration of IWOCS showed only marginal performance gains. This also illustrates how IWOCS can accomodate sub-optimal value functions and policies.)
Results for all methods other than IWOCS are taken from the work of Tanabe et al. ().
All results reported below are averaged over 10 distinct random seeds.

#### IWOCS*.

We define a variant of IWOCS by replacing CMA-ES with a plain grid search across the uncertainty set, mimicking the worst case search of Tanabe et al. (), in order to assess whether CMA-ES effectively finds adequate worst-case transition models.

Contrarily to CMA-ES, this will not scale to larger uncertainty set dimensions, but provides a safe baseline for optimization performance.

#### Worst-case performance.

Table 1 reports the normalized worst-case scores comparing IWOCS, M2TD3, SoftM2TD3, M3DDPG, RARL, and DR using TD3.(^6^66Note that this DR agent is independent of the one we use as a default policy for IWOCS.)

The worst-case scores for all final policies are evaluated by defining a uniform grid over the transition function’s parameter space and performing roll-outs for each transition model.

To obtain comparable metrics across environments, we normalize each method’s score $v$ using the vanilla TD3
(trained on the default transition function only)

reference score $v_{TD3}$ as a minimal baseline and the M2TD3 score $v_{M2TD3}$ as target score: $(v-v_{TD3})/|v_{M2TD3}-v_{TD3}|$.
Hence this metric reports how much a method improves upon TD3, compared to how much M2TD3 improved upon TD3.
Non-normalized scores are reported in Appendix K.
IWOCS* and IWOCS demonstrate competitive performance, outperforming all other methods in 7 out of the 11 environments (note that we did not report results on

simpler 1D uncertainty sets).

IWOCS* permits a $2.04$-fold improvement on average across environments, over the state-of-the-art M2TD3.
This validates in practice the soundness of solving a sequence of static models as an alternative to traditional methods building on dynamic models of uncertainty.
It seems that Ant is an environment where IWOCS struggles to reach convincing worst case scores.
We conjecture this is due to the wide range of possible mass and friction parameters, which make the optimization process very noisy (almost zero mass and friction is a worst-case $T$ making the ant’s movement rather chaotic and hence induces a possibly misleading replay buffer) and may prevent the policy optimization algorithm to yield good non-robust policies and value functions given its sample budget.
However, IWOCS provides a major (up to 6.5-fold) improvement on other environments.

#### Average performance.

While our primary aim is to maximize the worst-case performance, we also appreciate the significance of average performance in real-world scenarios.
Table 2 reports the normalized average score (non-normalized scores in Appendix K) obtained by the resulting policy over a uniform grid of 100 transition functions in 2D uncertainty sets (1000 in 3D ones).
Interestingly, M3DDPG and RARL feature negative normalized scores and perform worse on average than vanilla TD3 on most environments (as M2TD3 on 3 environments).
DR and IWOCS display the highest average performance.
Although this outcome was anticipated for DR, it may initially seem surprising for IWOCS, which was not explicitly designed to optimize mean performance.
We posit this might be attributed to two factors.

First, in MDPs which have not been identified as worst-cases, encountered states are likely to have no valid $Q_{T_{j}}$ value function.
In these MDPs, if we were to apply any of the $\pi_{T_{j}}$, its score could be as low as the worst cast value (but not lower, otherwise the MDP should have been identified as a worst case earlier).
But since IWOCS’ indicator functions identify these states as unvisited, the applied policy falls back to the DR policy, possibly providing a slightly better score above the worst case value for these MDPs.
Second, the usage of indicator functions permits defining the IWOCS policy as an aggregate of locally optimized policies, possibly avoiding averaging issues.
As for the worst-case scores, IWOCS does not perform well on Ant environments.
However, it provides significantly better average scores than both DR and M2TD3 on all 9 other benchmarks.

Table: Table 1: Avg. of normalized worst-case performance over 10 seeds for each method (HC=half-cheetah, H=hopper, HS=humanoid-standup, IP=inverted-pendulum, W=walker).

Table: Table 2: Avg. of normalized average performance over 10 seeds for each method.

Table: Table 3: Humanoid standup 2, worst parameters search for each iteration over 10 seeds.

#### Worst case paths in the uncertainty set.

IWOCS aims at solving iteratively the robust optimization problem by covering the worst possible case at each iteration.
IWOCS and IWOCS* seem to reliably find worst case MDPs and policies in a number of cases, and we could expect the value of the candidate robust policy $\pi_{i}$ to increase throughout iterations.
Table 3 permits tracking the worst case MDPs and policies along iterations for the Humanoid 2D environment (all other results in Appendix M).
Specifically, it reports the worst case $T_{1}=(\psi_{1}^{0},\psi_{1}^{1})$ for the default policy $\pi_{0}$, and its score $J^{\pi_{0}}_{T_{1}}$ (all scores are divided by $10^{4}$ for readability).
The next set of columns repeats these values for later iterations.
Each line corresponds to a different random seed.
In all lines, the worst case value $J^{\pi_{i}}_{T_{i+1}}$ steadily increases until convergence.
In some runs (last 4 seeds), IWOCS’s stopping criterion is met after a single iteration: the worst case $T_{2}=(7.21,14.41)$ for $\pi_{1}$ is the same as $T_{1}$, upon which $\pi_{1}$ was trained.
Overall the path through transition models and candidate robust policies illustrates the algorithmic behavior of IWOCS.
As indicated in Section 4, IWOCS is guaranteed to converge but may miss the optimal $(T,\pi)$ pair because the selection criterion for $T_{i+1}$ is a (well motivated) heuristic.
This happens for a few seeds, where IWOCS seems to reach a different saddle point after 2 or 3 iterations.

## 6 Conclusion

The search for robust policies in uncertain MDPs is a long-standing challenge.
In this work, we proposed to revisit the static model of transition function uncertainty, which is equivalent to the dynamic model in the case of $sa$-rectangular uncertainty sets and stationary policies.
We proposed to exploit this equivalence and the no-duality-gap property to design an algorithm that trades the resolution of a two-player game, for a sequence of one-player MDP resolutions.
This led to the IWOCS (Incremental Worst-Case Search) meta-algorithm, which incrementally builds a discrete, non-$sa$-rectangular uncertainty set and a sequence of candidate robust policies.
An instance of IWOCS, using SAC for policy optimization, and CMA-ES or grid-search for worst-case search, appeared as a relevant method on popular robust RL benchmarks, and outperformed the state-of-the-art algorithms on a number of environments.
IWOCS proposes a new perspective on the resolution of robust MDPs and robust RL problems, which appears as a competitive formulation with respect to traditional methods.
It also poses new questions, like the tradeoffs between policy optimization precision and overall robustness, gradient-based methods for worst-case search, bounds due to approximate value functions, or validity of using $Q_{i}$ as a surrogate of the robust value function for the $\mathcal{T}_{i}$ uncertainty set.
All these open interesting avenues for future research.

## Appendix A Appendix

## Appendix B Key results from the literature

In order to ease the reading of this paper, we recall the two theoretical results that Section 2 builds upon.
We reproduce the text from the original papers [Iyengar, , Wiesemann et al., ] but, for the sake of consistency, we use the notations of the present paper and indicate [in brackets] whenever we adjusted the original notation.
All results quoted below apply to $sa$-rectangular uncertainty sets.

Definition of the static and dynamic models, in the introduction of section 3 of [Iyengar, ].

> (i) Static model: The adversary is restricted to choose the same, but unknown, [$T(\cdot|s,a)$] every time the state-action pair $(s,a)$ is encountered. (ii) Dynamic model: The adversary is allowed to choose a possibly different conditional measure [$T(\cdot|s,a)$] every time the state-action pair $(s,a)$ is encountered. […] As mentioned in the introduction, the goal of the robust formulation is to systematically mitigate the effect of errors associated with estimating the state transitions; i.e., the state transition is, in fact, fixed but the decision maker is only able to estimate it to within a set. Thus, the static model is appropriate for this scenario. However, computing the optimal policy for the static model is NP-hard, therefore, we will restrict attention to the dynamic model. Clearly the value function in the dynamic model is a lower bound for the value function in the static model. We contrast the implications of the two models in Lemma 3.3.

Equivalence of the value functions under the static and dynamic models [Iyengar, , Lemma 3.3].

> Lemma 3.3 (Dynamic vs. static adversary). Let [$\pi:\mathcal{S}\rightarrow\mathcal{A}$ be a] stationary policy. Let $V^{\pi}$ and $\hat{V}^{\pi}$ be the value of the $\pi$ in the dynamic and static model respectively. Then $V^{\pi}=\hat{V}^{\pi}$. […] In the proof of the result we have implicitly established that the “best-response” of dynamic adversary when the decision maker employs a stationary policy is, in fact, static […].

Non-equivalence of the static and dynamic models for non-stationary policies, at the end of Section 3 of [Iyengar, ]

> Lemma 3.3 highlights an interesting asymmetry between the decision maker and the adversary that is a consequence of the fact that the adversary plays second. While it is optimal for a dynamic adversary to play static (stationary) policies when the decision maker is restricted to stationary policies, it is not optimal for the decision maker to play stationary policies against a static adversary.

No-duality gap property [Wiesemann et al., , Equation 4].

> To date, the literature on robust MDPs has focused on (s, a)-rectangular ambiguity sets. For this class of ambiguity sets, it is shown in [Iyengar, ] and [Nilim and El Ghaoui, ] that the worst-case expected total reward […] is maximized by a deterministic stationary policy for finite and infinite horizon MDPs. Optimal policies can be determined via extensions of the value and policy iteration. For some ambiguity sets, finding an optimal policy, as well as evaluating (2) for a given stationary policy, can be achieved in polynomial time. Moreover, the policy improvement problem satisfies the following saddle point condition $\sup_{\pi}\inf_{T\in\mathcal{T}}\mathbb{E}\left[\sum_{t=0}^{\infty}\gamma^{t}r (s_{t},a_{t},s_{t+1})|s_{0}\right]=\inf_{T\in\mathcal{T}}\sup_{\pi}\mathbb{E} \left[\sum_{t=0}^{\infty}\gamma^{t}r(s_{t},a_{t},s_{t+1})|s_{0}\right]$

## Appendix C Notations

Table 4 recalls all key notations used throughout the paper. The first block in Table 4 is for standard (non-robust) MDP quantities (used in Section 2 and after), the second for standard robust MDP quantities (Section 2 and after), the third for IWOCS-specific quantities (Section 4 and after), and finally the fourth for Deep-IWOCS notations (Section 5 and after).

**Table 4: Key notations**
| Symbol | Meaning |
| --- | --- |
| $M_{T}=(\mathcal{S},\mathcal{A},T,r)$ | MDP with transition kernel $T$ |
| $\pi$ | Stationary policy $\mathcal{S}\rightarrow\mathcal{A}$ |
| $V^{\pi}_{T}$, $Q^{\pi}_{T}$ | State and state-action value functions of policy $\pi$ in $M_{T}$ |
| $J^{\pi}_{T}$ | Scalar value $V^{\pi}_{T}(s_{0})$ of initial state under $\pi$ in $M_{T}$ |
| $\pi^{*}_{T}$ | Optimal policy in $M_{T}$ |
| $V^{*}_{T}$, $Q^{*}_{T}$ | Optimal state and state-action value functions in $M_{T}$ |
| $\mathcal{T}$ | Uncertainty set |
| $V^{\pi}_{\mathbf{T}}$ | Value function of policy $\pi$ under sequence of transition kernels $\mathbf{T}$ |
| $V^{\pi}_{\mathcal{T}}$, $Q^{\pi}_{\mathcal{T}}$ | Pessimistic value function of policy $\pi$ for uncertainty set $\mathcal{T}$ |
| $V^{*}_{\mathcal{T}}$, $Q^{*}_{\mathcal{T}}$ | Robust value function for uncertainty set $\mathcal{T}$ |
| $\mathcal{T}_{i}$ | Non-$sa$-rectangular discrete uncertainty set |
| $\tilde{\mathcal{T}}_{i}$ | $sa$-rectangular uncertainty superset of $\mathcal{T}_{i}$ |
| $Q_{i}$ | $T_{i}$-robust value function |
| $\pi_{T}$ | SAC’s approximation of $\pi^{*}_{T}$ |
| $Q_{T}$ | SAC’s approximation of $Q^{*}_{T}$ |
| $Q^{\prime}_{T}$ | SAC’s estimate of $\pi_{T}$’s regularized value function |
| $\hat{T}_{j}$ | Predictive coding model for $T_{j}$ |

## Appendix D Computing resources

All experiments were run on a desktop machine (Intel i9, 10th generation processor, 64GB RAM) with a single NVIDIA RTX 3090 GPU.
Averages, medians, and standard deviations were computed from 10 independent repetitions of each experiment.

## Appendix E Windy-walk gridworld

The windy-walk environment used in Section 4 is a discrete grid-world environment illustrated in Figure 2.
It features 36 discrete states corresponding to positions on the grid, and 4 discrete actions corresponding to cardinal moves.
Six states are unreachable and correspond to walls, defining three corridors.
The transition model is deterministic by default, except in the corridors where the wind blows. This transition model is parameterized by a scalar parameters $\alpha$. In the Northern corridor:

- •
the $W$ action moves West with probability 1,
- •
the $N$ and $S$ actions leave the position unchanged with probability $1-\alpha$ and the agent is pushed West with probability $\alpha$,
- •
the $E$ action moves East with probability $1-\alpha$ and West with probability $\alpha$.

The middle corridor works the same way, but with probability $\alpha^{3}$ instead of $\alpha$.
In the Southern corridor:

- •
the $W$ action moves West with probability 1,
- •
the $N$ (resp. $S$) action move the agent respectively North (resp. South) with probability $1-\alpha^{6}$ (unless it runs into a wall in which case the position is unchanged), and West with probability $\alpha^{6}$,
- •
the $E$ action moves East with probability $1-\alpha^{6}$ and West with probability $\alpha^{6}$.

Rewards are -1 for all transitions and the $G$ state is an absorbing goal states yielding zero reward.
The agent always starts in state $S$.
Consequently, windy-walk is a stochastic shortest path.
For small values of $\alpha$, the optimal policy is to go straight from $S$ to $G$, but as $\alpha$ increases, the wind blows harder, and it becomes more interesting to make a detour through the middle then Southern corridors.
The corresponding robust MDP problem features an uncertainty set spanned by 25 discrete values of $\alpha$, uniformly distributed in $[0,0.5]$.

The instance of IWOCS evaluated in Section 4 uses value iteration as a policy optimization algorithm and a brute-force grid search as a search method for worst-case transition functions, as summarized in Algorithm 2. In Algorithm 2 we abusively write $T_{\alpha}$ the transition model parameterized by $\alpha$.

In the experiments of Section 4, value iteration is run until a tolerance of $10^{-3}$ is met. $\gamma$ is set to $0.95$. Monte-Carlo estimates of $V^{\pi_{i}}_{T}(s_{0})$ use 300 independent rollouts (of length at most $10^{4}$) from the starting state.

Figure: Figure 2: Windy walk grid-world.
Refer to caption: extracted/5910764/medias/toy_env_viz.png

Figure: Algorithm 2 IWOCS with value iteration and brute force worst-case search

## Appendix F Soft Actor-Critic and CMA-ES hyperparameters

Deep IWOCS uses SAC [Haarnoja et al., ] for policy optimization and trains jointly a predictive coding model to predict the outcome of a state-action pair.
Specifically, a single network called “enhanced critic” is trained to predict the regularized value function $Q^{\prime}(s,a)$, the unregularized value function $Q(s,a)$ and a prediction of the transition outcome $\hat{T}(s,a)$.
The critic network’s architecture is summarized in Figure 3(a). All activation functions are ReLU except for the output layers (identity functions).
Note that one more layer was necessary to appropriately estimate $Q$ compared to $Q^{\prime}$.
Our implementation also uses double critics as per the common practice, to avoid overestimating $Q$ and $Q^{\prime}$ (totally independent networks, no shared layers).
Given a replay buffer $\mathcal{D}$, learning $Q$ minimizes the loss

$$ $L_{Q}=\mathbb{E}_{s,a,s^{\prime}\sim\mathcal{D},a^{\prime}\sim\pi}\left[Q(s,a) -[r+\gamma Q^{-}(s^{\prime},a^{\prime})]\right]^{2},$ $$

where $Q^{-}$ is a target network, updated through Polyak averaging.
Similarly, $Q^{\prime}$ minimizes

$$ $L_{Q}^{\prime}=\mathbb{E}_{s,a,s^{\prime}\sim\mathcal{D},a^{\prime}\sim\pi} \left[Q^{\prime}(s,a)-[r+\gamma(Q^{\prime-}(s^{\prime},a^{\prime})-\alpha\log \pi(a^{\prime}|s^{\prime}))]\right]^{2}.$ $$

Finally, $\hat{T}$ minimizes

$$ $L_{\hat{T}}=\mathbb{E}_{s,a,s^{\prime}\sim\mathcal{D}}\left[\|\hat{T}(s,a)-s^{ \prime}\|_{1}\right].$ $$

These three objective functions are minimized in turn with three distinct Adam optimizers to account for possible different orders of magnitude.

Figure: (a) Enhanced critic
Refer to caption: extracted/5910764/medias/critic_dynamic.png

The actor network is a standard SAC actor trained with respect to the regularized Q-function $Q^{\prime}$.
The network’s architecture is depicted in Figure 3(b).
All activation functions are ReLU, except for the output values (identify for $\mu$ and $\tanh$ for $\log\sigma$ as per the common practice).
The output action drawn from the network’s output is run through an additional $\tanh$ function following the usual SAC implementations.

The search for worst case transition functions is performed by using the CMA-ES black-box optimization method [Hansen and Ostermeier, ].
The implementation used is the reference one of [https://github.com/CyberAgentAILab/cmaes](https://github.com/CyberAgentAILab/cmaes), off-the-shelf.

All hyperparameter values for SAC and CMA-ES are summarized in Table 5.
These values are the same across all experiments.

**Table 5: Hyperparameters of SAC**
| Hyperparameter | Value |
| --- | --- |
| Learning rate actor | 3e-4 |
| Learning rate critic | 1e-3 |
| Adam epsilon | 1e-5 |
| Adam $(\beta_{1},\beta_{2})$ | (0.9, 0.999) |
| Batch size | 256 |
| Memory size | 1e6 |
| Gamma | 0.99 |
| Polyak update | 0.995 |
| Number of steps before training | 1e4 |
| CMA-ES generations | 6 |
| CMAS-ES population size | 100 |
| CMA ES mean | 0.5 |
| CMA ES std | 0.5 |

## Appendix G Adaptive thresholding for predictive coding

As introduced in Section 5, the SAC-based implementation of IWOCS used in the experiments exploits a predictive coding mechanism in order to characterize each policy’s training distribution support and to avoid using a given $\pi_{T_{i}}$ on samples outside its training distribution.
Policy $\pi_{T_{i}}$ and value function $Q_{T_{i}}$ are deemed usable in state $s_{t}$ along the current trajectory if $s_{t}$ was accurately predicted by the dynamics model $\hat{T}_{i}(s_{t-1},a_{t-1})$.
Specifically, we consider a threshold $\rho_{i}$ on the prediction error and consider $Q_{T_{i}}$ and $\pi_{T_{i}}$ to be viable in $s_{t}$ if $\ell(\hat{T}_{i}(s_{t-1},a_{t-1}),s_{t})\leq\rho_{i}$, with $\ell(\hat{T}_{i}(s_{t-1},a_{t-1}),s_{t})=\|\hat{T}_{i}(s_{t-1},a_{t-1})-s_{t}
\|_{1}$.
In states where $Q_{T_{i}}$ is non-viable, we arbitrarily set its value to $+\infty$ so that it does not participate in $Q_{i}(s,a)=\min_{j\leq i}\{Q_{T_{j}}(s,a)\}$.
We noted in the main text that alternative characterizations of the support distribution were possible, and we do not claim the present choice outperforms the alternatives.
Notably, all choices induce a number of parameters to tune (here $\rho_{i}$).
This leads to a number of design choices that make the implementation somehow more convoluted than the simple principle of IWOCS.
While the main text kept things focused on the principles of IWOCS, we provide here a full pseudo-code (which is more representative of the provided code) for the sake of completeness.
Appendix F already covered the network structure, the training losses and the training hyperparameters for SAC and CMA-ES.
Hence, the present section focuses on how to adjust each $\rho_{i}$.

Training of the enhanced critic network does not provide a usable value for $\rho_{i}$ and experimental results demonstrated that accurate characterization of the training distribution’s support required per-MDP tuning.
Since $\rho_{i}$ needs to be tuned for $\pi_{T_{i}}$ during iteration $i$ (and is kept fixed thereafter), we couple its search with that of the worst case transition model to permit better overall efficiency.
Specifically, at iteration $i$, we consider a discrete set $R$ of possible values for threshold $\rho_{i}$.
For each value in $R$, we identify the worst case transition model.
Then, we keep the value of $\rho_{i}$ that enabled the best pessimistic value.
In a sense, this makes $\rho_{i}$ a parameter of the candidate robust policy.
This parameter is single-dimensional and hence its optimization is computationally undemanding.
We emphasize that this tuning mechanism is both very naive and arbitrary.
It is naive since it performs a grid search over discrete values of $\rho_{i}$, where it could have exploited optimization methods.
It is arbitrary in the sense that it picks $\rho_{i}$ by keeping as a selection heuristic the overall goal of identifying robust policies.

Algorithm 3 summarizes the complete IWOCS process with adaptive thresholding for predictive coding.
In the experiments of Section 5, $R$ is a discrete set of 10 values evenly spaced between $0.1$ and $1$.

Figure: Algorithm 3 Deep IWOCS with adaptive threshold

## Appendix H Sample budgets

In order to enable a fair comparison with the results of Tanabe et al. [] which we report in Table 1, we evaluate IWOCS with the same overall sample budget, ie. 4 million samples in 2D uncertainty set environments and 5 million samples in 3D uncertainty set environments.

In 2D environments, the default DR policy is trained for $1.6\cdot 10^{6}$ steps, then 3 IWOCS iterations of $8\cdot 10^{5}$ each are run, for a total of $4\cdot 10^{6}$ collected samples.

In 3D environments, the default DR policy is trained for $1.8\cdot 10^{6}$ steps, then 4 IWOCS iterations of $8\cdot 10^{5}$ each are run, for a total of $5\cdot 10^{6}$ collected samples.

No fine-tuning of these training durations was performed.

## Appendix I Computational overhead due to IWOCS

In Table 6 we report the average wall-clock time needed for our implementation of SAC to cover the 4 (resp. 5) million samples allocated for 2D (resp. 3D) environments without IWOCS. Then, we report the time required by IWOCS to cover the same sample budget. This permits a fair evaluation of the overhead computational cost of IWOCS, without the bias due to implementation optimizations.

**Table 6: Average wall-clock time for plain SAC and for IWOCS for the same number of samples.**
| Environment | SAC | IWOCS |
| --- | --- | --- |
| Ant 2 | 18h | 36h |
| Ant 3 | 22.5h | 40h |
| Halfcheetah 2 | 20h | 38.5h |
| Halfcheetah 3 | 25h | 41h |
| Walker 2 | 19h | 40h |
| Walker 3 | 24h | 45h |
| Hopper 2 | 20h | 38h |
| Hopper 3 | 25h | 47h |
| HumanoidStandup 2 | 18h | 40h |
| HumanoidStandup 3 | 22.5h | 48h |

## Appendix J Uncertainty sets in MuJoCo environments

The experiments of Section 5 follow the evaluation protocol proposed by Tanabe et al. [] and based on MuJoCo environments [Todorov et al., ].
These environments are designed with 2D or 3D uncertainty sets.
Table 7 lists all environments evaluated, along with their uncertainty sets.
The uncertainty sets column defines the ranges of variation for the parameters within each environment.
The reference parameters column indicates the nominal or default values.
The uncertainty parameters column describes the physical meaning of each parameter.

Table: Table 7: List of environment and parameters for the experiements

## Appendix K Non-normalized results

Table 8 reports the non-normalized worst case scores, averaged across 10 independent runs for each benchmark.
Table 9 reports the average score obtained by each agent across a grid of environments, also averaged across 10 independent runs for each benchmark.

Table: Table 8: Avg. $\pm$ std. error of worst-case performance over 10 seeds for each method

Table: Table 9: Avg. $\pm$ std. deviation of average performance over 10 seeds for each method

## Appendix L Soft Actor Critic baseline

We conducted additional experiments using SAC to train on the reference transition kernel across all environments. These experiments aimed to confirm the performance similarities with TD3 and to emphasize the performance gap with IWOCS. The results are summarized in Table 10.

Overall, SAC performs poorly in terms of worst-case score, reinforcing our earlier observation of its similarity to TD3. Specifically, SAC exhibits variability across different environments, sometimes outperforming TD3 and sometimes not. However, the scores generally remain within the same order of magnitude. For instance, in the Hopper environment, SAC achieves scores of 14 and 5.8 on Hopper 2 and Hopper 3, respectively, which surpass previous state-of-the-art methods. Despite this, IWOCS still shows a significant improvement, with final scores of 32.68 and 12.66, respectively. These results highlight the distinct advantages of our approach in achieving robust performance.

**Table 10: Avg $\pm$ std. error of worst-case performance over 10 for SAC**
| Environment | Avg ± Std |
| --- | --- |
| Ant 2 | -1.0 ± 0.4 |
| Ant 3 | -2.1 ± 0.1 |
| Halfcheetah 2 | -0.2 ± 0.002 |
| Halfcheetah 3 | -0.26 ± 0.04 |
| Hopper 2 | 14 ± 0.99 |
| Hopper 3 | 5.8 ± 0.4 |
| Humanoid 2 | 3.8 ± 0.1 |
| Humanoid 3 | 3.6 ± 0.27 |
| Walker 2 | 0.8 ± 0.9 |
| Walker 3 | 0.5 ± 0.7 |

## Appendix M Worst-case paths

Table 3 illustrated the path followed by the successive identified worst-case transition functions $T_{i}$ in the 2D uncertainty set of the Humanoid Standup 2 environment, across 10 independent optimization runs.
For the sake of completeness, we provide here the same results for all environments, which permit drawing similar conclusions.
Tables 11 and 12 start by recalling the physical meaning of each transition function’s parameters.
Then, Tables 13 to 21 follow the same logic as Table 3 and report the evolution of worst-case parameters and values on all other environments than Humanoid Standup 2.

**Table 11: Physical meaning of transition function parameters in 2D environments**
| Environment | $\psi_{1}$ | $\psi_{2}$ |
| --- | --- | --- |
| Ant 2 | torso mass | front left leg mass |
| Halfcheetah 2 | world friction | torso mass |
| Hopper 2 | world friction | torso mass |
| HumanoidStandup 2 | right foot mass | torsomass |
| Walker 2 | world friction | torso mass |

**Table 12: Physical meaning of transition function parameters in 3D environments**
| Environment | $\psi_{1}$ | $\psi_{2}$ | $\psi_{3}$ |
| --- | --- | --- | --- |
| Ant 3 | torso mass | front left leg mass | front right leg mass |
| Halfcheetah 3 | world friction | torso mass | back thigh mass |
| Hopper 3 | world friction | torso mass | thigh mass |
| HumanoidStandup 3 | torso mass | left thigh mass | right foot mass |
| Walker 3 | world friction | torso mass | thigh mass |

Table: Table 13: Ant 2, worst parameters search for each iteration over 10 seeds.

Table: Table 14: Halfcheetah 2, worst parameters search for each iteration over 10 seeds.

Table: Table 15: Hopper 2, worst parameters search for each iteration over 10 seeds.

Table: Table 16: Walker 2, worst parameters search for each iteration over 10 seeds.

Table: Table 17: Ant 3, worst parameters search for each iteration over 10 seeds.

Table: Table 18: Halfcheetah , worst parameters search for each iteration over 10 seeds.

Table: Table 19: Hopper 3, worst parameters search for each iteration over 10 seeds.

Table: Table 20: Humanoid 3, worst parameters search for each iteration over 10 seeds.

Table: Table 21: Walker 3, worst parameters search for each iteration over 10 seeds.

## Appendix N How many valid policies in s?

The Deep-IWOCS method proposed in Section 5 introduced indicator functions constraining the use of a given policy to a subset of states.
Depending on the environment and uncertainty parameters, we expect some policies to remain within the same set of explored states, while others will cover a very different state distribution.
To quantify this aspect, we ran an experiment where the IWOCS final policy is run on the Hopper 3 benchmark, across a grid of transition functions.
For each encountered state, we count how many policies are valid.
Figure 4 reports the corresponding histograms (note the log-scale on the $y$-axis).

Figure: Figure 4: Counting how many policies are valid in each state, in Hopper 3
Refer to caption: extracted/5910764/medias/histo_Hopper_3.png

## Appendix O Discussion on the complexity of IWOCS

Recall that the complexity of robust value iteration (RVI) in discrete state and action MDPs is $O(Cn_{S}\log(1/\epsilon)/\log(1-\gamma))$, where $n_{S}$ is the number of states, $\epsilon$ is the tolerance for the robust value function and $C$ is the cost of computing $\max_{a}\min_{T}\mathbb{E}_{R,S^{\prime}}[R+\gamma V(S^{\prime})]$ in a given $s$ [Iyengar, ].
In discrete state and action spaces, computing the value of the expectation has cost O($n_{S}$).
The $\min_{T}$ has to be solved once for every state and action and it’s a search over measures on $S$.
Let $c$ be its cost, and $n_{A}$ be the number of actions, then the cost of the $\max_{a}\min_{T}$ operation is $O(cn_{S}n_{A})$ for a $sa$-rectangular uncertainty set and the overall complexity of RVI is $O(cn_{S}^{2}n_{A}\log(1/\epsilon)/\log(1-\gamma))$.

Recall also that the complexity of value iteration (VI) is $O(n_{S}^{2}n_{A}\log(1/\epsilon)/\log(1-\gamma))$ (VI is a special case of RVI with a singleton as uncertainty set, so $c=1$).
The ratio between the two complexity bounds is $c$.

Comparing IWOCS and RVI is a delicate matter because IWOCS is not based on a contraction mapping and has no convergence guarantees to the robust value function.
Consequently, comparisons should be taken with a grain of salt.
Yet, it is legitimate to wonder whether one can analyse the time complexity of IWOCS versus RVI.
One iteration of IWOCS in discrete state and action spaces, as presented in Section 4, has the complexity of VI for the policy search part, plus the complexity of finding a worst case transition function in an $sa$-rectangular uncertainty set, which is $O(cn_{S}n_{A})$.
Hence, the overall complexity for $M$ iterations of IWOCS is $O(M(n_{S}^{2}n_{A}\log(1/\epsilon)/\log(1-\gamma)+cn_{S}n_{A}))$.
Compared to RVI (depending on $M$ which we cannot easily quantify), this bound will be smaller when $c$ is large, which is the case when one deals with complex uncertainty sets and without further hypotheses.

This short discussion provides a rationale to why IWOCS might be a time-efficient algorithm in large scale robust RL problems.

## Appendix P On the variance of the domain randomization policy

Domain randomization on the full uncertainty set yields policies with a very large span of worst-case scores from one random seed to the other (Table 22).
In other words, DR provides policies with a very large variance in worst-case performance.
In turn, running a separate DR training for each seed of IWOCS induces a large variance on scores across seeds from the first iteration.
IWOCS still converges, but this variance is carried through the iterations.
For the sake of completeness, Table 23 report the scores of IWOCS and IWOCS* with a varying starting policy which is issued from the (very noisy) DR optimization process.
Interestingly, even with these very noisy policies, IWOCS still outperforms other algorithms on average across environments.
However the variance of obtained scores is quite high.
The columns of Table 23 should be compared with those of Table 1 in the main text of the paper, showing that variance in IWOCS’ performance with variables DR initial policy is mostly due to the large variance in DR’s initial policies.

**Table 22: Worst-case score distribution of $\pi_{0}$ trained with DR on each environment.**
| Environment | $J^{\pi_{0}}_{T_{1}}$ |
| --- | --- |
| Ant 2 | $-0.43\pm 0.96$ |
| Ant 3 | $-0.32\pm 0.50$ |
| HalfCheetah 2 | $0.66\pm 0.30$ |
| HalfCheetah 3 | $0.41\pm 0.11$ |
| Hopper 2 | $1.78\pm 2.16$ |
| Hopper 3 | $2.33\pm 1.44$ |
| HumanoidStandup 2 | $0.51\pm 0.50$ |
| HumanoidStandup 3 | $0.45\pm 0.89$ |
| InvertedPendulum 2 | $2.32\pm 0.42$ |
| Walker 2 | $1.06\pm 0.29$ |
| Walker 3 | $1.74\pm 0.40$ |
| Aggregated | $0.96\pm 0.72$ |

**Table 23: Avg. of normalized worst-case performance over 10 seed for IWOCS* and IWOCS without fixed initial policy**
| Environment | IWOCS* without fixed $\pi_{0}$ | IWOCS without fixed $\pi_{0}$ |
| --- | --- | --- |
| Ant 2 | $0.12\pm 0.81$ | $-0.27\pm 0.44$ |
| Ant 3 | $0.19\pm 0.52$ | $0.43\pm 0.68$ |
| HalfCheetah 2 | $0.72\pm 0.31$ | $0.75\pm 0.28$ |
| HalfCheetah 3 | $0.51\pm 0.18$ | $0.56\pm 0.15$ |
| Hopper 2 | $5.41\pm 1.15$ | $6.34\pm 0.11$ |
| Hopper 3 | $4.34\pm 0.32$ | $4.64\pm 0.16$ |
| HumanoidStandup 2 | $0.69\pm 0.30$ | $0.98\pm 0.25$ |
| HumanoidStandup 3 | $0.86\pm 0.72$ | $1.12\pm 0.21$ |
| InvertedPendulum 2 | $2.82\pm 0.00$ | $2.82\pm 0.00$ |
| Walker 2 | $1.14\pm 0.30$ | $1.23\pm 0.10$ |
| Walker 3 | $1.90\pm 0.42$ | $2.10\pm 0.50$ |
| Aggregated | $1.7\pm 0.46$ | $1.88\pm 0.26$ |

## Appendix Q Impact statement

This paper presents work whose goal is to advance the field of reinforcement learning. It tackles generic mathematical and computational challenges, which might have potential societal and technological consequences, none of which we feel must be specifically highlighted here.

## Appendix R Limitations

The IWOCS algorithm assumes that all transition kernels in the uncertainty set $\mathcal{T}$ are known during training. In real-world applications, obtaining such detailed information is not always feasible. This reliance on precise uncertainty set knowledge limits the practical usage of our algorithms in some cases.

Another limitation of the Deep IWOCS algorithm is the need for hand-tuning or grid-search for the threshold $\rho$. A promising approach is using a variance network to detect non-valid value functions automatically. We plan to work on this for future developments.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: - How does the sampling-based approach converge as the number of samples increases? Can the authors provide more analyses (theoretical and experimental)  to support the sampling-based approach?
- Would this approach work with non-rectangular uncertainty sets?
- How does your method compared to model-free algorithms (e.g, Q-learning, SAC, PPO, TRPO ...)?
- How does your method perform with other environments  other than Mujoco (Atari, DM control)?
- Could a simple dual-gradient method solve the minimax problem?
soundness: 2
strengths: - Robust MDP is an important area of study.
- The proposed algorithm appears simple to implement.
- The Deep IWOC represents a meaningful improvement over existing robust MDP methods, which mainly focus on discrete state-action spaces.
summary: The paper addresses the robust MDP problem in the context of uncertain transition dynamics, assumed to lie within a rectangular uncertainty set. Building on the non-duality-gap property established in previous work, the authors propose a discretization approach to tackle the adversarial problem. Specifically, they sample transition functions from the uncertainty set and iteratively solve the non-robust problem using the sampled transition dynamics. A deep version is also introduced to handle continuous state-action spaces. Numerical results are provided on various MuJoCo benchmarking tasks, comparing the proposed methods with other robust MDP approaches.
weaknesses: - The primary sampling-based approach raises significant concerns. Typically, solving a max (or min) problem through sampling requires an exponential number of points to achieve the desired accuracy, making this approach generally intractable from a theoretical standpoint. 

- There is no discussion on the number of transition samples needed to obtain a robust solution.

- The sampling-based approach appears overly simplistic and could be seen as a straightforward baseline for robust MDP. Combined with the lack of theoretical analysis (e.g., theoretical analyses on the impact of the number of samples on the convergence), the contributions feel incremental.

- The proposed algorithm does not seem scalable. The authors should consider comparisons with some model-free algorithms and test on larger benchmarking tasks.

---

confidence: 5
contribution: 1
initial_rating: 1
presentation: 2
questions: * The contrast with dynamic uncertainties is an odd choice. That is a generalization of the model considered in the paper. Why would one claim that the setting in the paper is more challenging? Especially without even giving a precise description of what is more challenging.
soundness: 1
strengths: * The general problem targeted by the paper is relevant and timely. 
* The amount of empirical results is appropriate.
summary: The paper targets reinforcement learning for MDPs whose transition probabilities are known up to an uncertainty set. Hence, it aims to robustify against these uncertainties and justify the proposed approach empirically.
weaknesses: * It is hard to talk about soundness of the results because there is no precise problem statement. 
* As such, it is impossible to prove a meaningful result, which is critical when dealing with uncertainties and their impact on performance and safety. 
* The literature within which the paper places itself misses a large body of more relevant work on RL and IRL (which solves a series of RL problems as a subroutine) for robust/uncertain MDPs. This body of work originates from probabilistic formal methods and investigates how existing approaches for planning in robust/uncertain MDPs can be utilized in RL. Examples include the following. https://www.prismmodelchecker.org/papers/neurips22.pdf, https://arxiv.org/html/2312.06344v1, https://arxiv.org/html/2312.06344v1, https://ojs.aaai.org/index.php/ICAPS/article/view/19785
* The method is, at best, ad hoc. The implementation leaves many choices to the user.

---

confidence: 3
contribution: 2
initial_rating: 3
presentation: 2
questions: Could you please elaborate on the differences between the proposed method and the approach from Gadot et al. (2024)?
soundness: 3
strengths: - The quality of the paper is high. The arguments are presented in a concise and effective way. The description of the algorithm for the tabular case is precise. 
- The writing is clear, and the mathematical notation is precise.
- Strong empirical results against the baseline algorithms under consideration.
summary: This paper proposes solving a robust MDP using a worst-case model search. In particular, it focuses on a static model, where the transition function does not change during trajectory. This setting ensures that the policy computed is less conservative than a policy that solves for a dynamic model. However, solving problems with a static model is harder than problems with dynamic models.

To mitigate this issue, the paper assumes the agent optimizes a stationary policy. Under such assumption, the paper shows that it is sufficient to find optimize for the worst-case transition function: $V^*_\mathcal{T}(s)  = \min_{T\in \mathcal{T}}V^*_T(s)$.

In this case, given the uncertainty set, the proposed approach interleaves the optimization of the policy and the update of the transition dynamics, effectively searching for the worst-case transition function.

The paper provides empirical evidence that the method can converge to robust policies in a tabular setting as well as in a function approximation setting, adapting the SAC method to handle such a sequence of problems.
weaknesses: - The main weakness of the paper is its originality. This is limited since prior work proposes a similar approach to estimate the worst-case MDP to compute a robust policy based on a single transition function (Gadot et al. 2024). 
- The significance of the proposed approach also seems limited when we put it in perspective with the work from Gadot et al. (2024), since this method requires a specialized implementation of the SAC algorithm, while the method from Gadot et al. (2024) does not requires any changes on the underlying RL algorithm. Furthermore, their method already shows the scalability of deep RL algorithms to robust settings, which puts the empirical contribution of this paper in check.
While the paper provides a considerable overview of the related work literature, it misses a key reference, as discussed above. The paper needs a clear discussion of such an approach and, if appropriate, an empirical comparison with it.
Lastly, the presentation of the worst-case identification on the deep IWOCS is difficult to parse. Furthermore, the provided supplemental material does not provide any instructions about how to use the code. A pseudo-code detailing this procedure and instructions to reproduce the experiment would significantly increase the clarity and reproducibility of the paper.   



- Gadot, U., Wang, K., Kumar, N., Levy, K. Y., and Mannor, S. (2024). Bring your own (Non-robust) algorithm to solve robust MDPs by estimating the worst kernel. *ICML*, 14408–14432. <https://proceedings.mlr.press/v235/gadot24a.html>

---

confidence: 3
contribution: 1
initial_rating: 3
presentation: 3
questions: 1. In line 199, the authors state, “We consider a (small) discrete set of MDPs,” yet it remains unclear why IWOCS is necessary in this context if $\min_{T \in \mathcal{T}} \max_{\pi} V_T^\pi(s_0)$ can be computed directly when the model uncertainty set of MDPs is small. Specifically, in Algorithm 1, it would be helpful to clarify the complexity of the "Find worst $T_{i+1} = \arg\min_{T \in \mathcal{T}} V_T^{\pi_i}(s_0)$" step compared to a direct computation of $\min_{T \in \mathcal{T}} \max_{\pi} V_T^\pi(s_0)$.

2. In line 252, the authors state that "$T_{i+1}$ can be chosen with another criterion than the worst-case without loosing property 1 and 2". However, for this to hold under alternative criteria, it may be necessary to assume equality when swapping the maximization over policies into other criteria. This assumption may not hold for criteria beyond average and extreme values, potentially limiting the generalizability of this claim.

3. In numerical experiment, the proposed method demonstrate a better performance than other robust RL algorithms. However, this algorithm aim to converge to the the optimizer for RVI, it is unclear to my why it would converge to a better rather than identical optimizer. It is because we worked in deep learning setting and the robust algorithm has no guarantee to converge to optimal? In tabular domain, would the proposed method and RVI have the same optimizer?
soundness: 3
strengths: (1) The paper is well-written, showcasing the authors' deep understanding of prior work and foundational concepts in the robust RL community. 

(2) The proposed methodology is clearly and comprehensively explained.

(3) The authors have thoroughly evaluated the performance of their algorithm across a wide range of deep RL control benchmarks, effectively validating its robustness and applicability.
summary: This work addresses the robust static MDP problem. It is worth noting that when optimizing over stationary policies, the optimal robust static MDP model is equivalent to the dynamic variant. The authors propose an iterative approach that incrementally identifies worst-case transition models. Specifically, given a finite set of uncertain transitions, the method iterates over the uncertainty set to find the optimal policy $\pi_i$ at each iteration $i$ until the condition $V_{T+1}^{\pi_i}(s_0) = Q_i(s_0,\pi_i(s_0))$ is satisfied. The authors further demonstrate a deep RL variant of their algorithm across a variety of standard deep RL benchmarks.
weaknesses: The paper has two main weaknesses:

(1) The primary weakness is the lack of theoretical contribution, as most theoretical results presented are well-known. The application of established theories such as the lack of duality gap and the equivalence between static and dynamic stationary models, to the IWOCS setting seems trivial and adds limited novelty. A more in-depth discussion of how IWOCS provides advantages (i.e. scalability analysis, sample complexity) over existing robust MDP algorithms would strengthen the paper. 

(2) The motivation of the paper appears somewhat contradictory. On one hand, it is stated that the static model is more challenging to solve than the dynamic model and is valuable for decision-makers seeking robustness to static transition model uncertainty. On the other hand, the authors note that, under mild assumptions, the static and dynamic models are equivalent. This positioning makes it seem as though the approach achieves similar outcomes to robust value iteration (RVI) but with added complexity. The paper could benefit from more detailed analysis of IWOCS against other robust algorithms beyond short discussion on "rationale to why IWOCS might be a time-efficient algorithm in large scale robust RL problems".

Minor Issue: Algorithm 1 missing close bracket in the if statement: $Q_i(s_0,\pi_i(s_0))$

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 2
questions: 1. In this work, IWOCS only considers a unique starting $s_0$ (Line 067). However, in some tasks such as continuous control tasks, we need to tackle the distribution $p(s_0)$. For example, as shown in Algorithm 2, we need to compute $V_{T_{i+1}}^{\pi_i}(s_0)$ and $Q_i(s_0,\pi_i(s_0))$ during training. How to compute these values for uncertain $s_0$?  Discuss how IWOCS might be extended to handle a distribution of starting states, such as in IWOCS+SAC algorithm for Mujoco control tasks.  
2. As shown in table 2&3, IWOCS* obtains higher performance than IWOCS, which is normal because IWOCS*  utilize grid-search rather than CMA-ES. Please provide a detailed comparison of computation times for IWOCS and IWOCS* across different uncertainty set dimensions. Discuss the trade-offs between performance and computation time when using grid-search vs CMA-ES, and provide guidelines for when to use IWOCS vs IWOCS* based on problem characteristics.
3. Can the idea proposed in this work be utilized in other robust RL problems, such as robust RL under observation perturbations? Please discuss any modifications or potential challenges when applying IWOCS to observation perturbation problems.
soundness: 3
strengths: 1. Improving robustness of RL against transition uncertainty is meaningful for downstream tasks, such as  RL applications on robotics.
2. The extensive experiments on classic and deep RL settings demonstrate the effectiveness of the new method, especially in tasks with continuous state space and action spaces.
summary: This work proposes a new robust RL methods for MDP with uncertain transitions called IWOCS (Incremental Worst-Case Search). This method incrementally builds a discrete, non-sa-rectangular uncertainty set and a sequence of candidate robust policies. IWOCS can be utilized for classic RL tasks with discrete state/action spaces and Deep RL domains with continuous task settings. The experiments on windy gridworld and Mujoco tasks demonstrate its effectiveness.
weaknesses: 1. In appendix. I, the author shows the training times for SAC and IWOCS in Mujoco control tasks. As shown in Table 6, IWOCS requires about twice time cost for training compared to SAC, leading to additional burdens in real applications. According to this phenomenon, please provide the following results to analyze and improve the new method:
    1. Provide a more detailed breakdown of where the additional computation time is spent in IWOCS (e.g. worst-case search, policy optimization, etc.). This would help identify specific areas for potential optimization.
    2. Provide potential methods or approaches to reduce the computational cost of IWOCS.
    3. Include training times for other baseline robust RL methods to provide more context for evaluating IWOCS's computational efficiency relative to the state-of-the-art.
2. This work focuses on the RL task with uncertain transition, such as robotics control with dynamic friction settings. This issue is also researched in Meta-RL domains, such as Meta RL methods with task inference. Such methods can adapt to new environment transitions with limited interactions. Please explain the relationship or difference of this work and such meta RL methods. A brief introduction of Meta-RL with uncertain transition should be included in the related work, with highlighting key similarities and differences between IWOCS and meta-RL approaches.
3. Some typos in the manuscript, such as  line 085: denote -> denotes

Meta-review: The paper develops Incremental Worst Case Search (IWOCS), a method designed to solve the robust RL problem (i.e. to find a single policy that works in any of a set of environments).

The main strengths of the paper are: (1) the problem is important; (2) the proposed algorithm is simple; (3) experiments are extensive.

I don't think that the paper is ready for the following reasons.
- Weak theory / no sample complexity guarantee.
- Presentation not very clear.
- Novelty issues relative to the Gadot paper.

For these reasons, and because the authors failed engage in a discussion with reviewers, I recommend rejection.

Decision: Reject