Minimizing the Outage Probability in a Markov Decision Process

TL;DR

This paper introduces a novel algorithm for Markov decision processes that optimizes the probability of achieving a gain above a certain threshold, extending traditional expected reward optimization.

Contribution

It presents an extension of value iteration to optimize outage probability and discusses how to incorporate neural networks for scalable solutions.

Findings

Algorithm effectively minimizes outage probability.

Extension to neural networks enables scalable implementation.

Potential for improved risk-sensitive decision making.

Abstract

Standard Markov decision process (MDP) and reinforcement learning algorithms optimize the policy with respect to the expected gain. We propose an algorithm which enables to optimize an alternative objective: the probability that the gain is greater than a given value. The algorithm can be seen as an extension of the value iteration algorithm. We also show how the proposed algorithm could be generalized to use neural networks, similarly to the deep Q learning extension of Q learning.

Equations

$$G_t=\sum _{i=t}^{\infty }{\lambda }^{i-t}{r}_i,$$

$$v^{\pi }(s)=\mathbb{E}[G_t|s].$$

$$v^{{\pi }^{\ast }}(s)\ge v^{\pi }(s),\forall s\in S\text{ and }\forall \pi .$$

$$v^{{\pi }^{\ast }}(s)=\underset{a\in A_s}{\max }Q(s,a),$$

$$Q(s,a)=\mathbb{E}[G_t|s,a]=R(s,a)+\lambda \sum _{s_j\in S}p(s_j|s,a)v^{{\pi }^{\ast }}(s_j),$$

$$a^{\ast }=\underset{a\in A_s}{\text{ arg max }}Q(s,a).$$

$$v_{n+1}(s)=\underset{a\in A_s}{\max }\{R(s,a)+\lambda \sum _{s_j\in S}p(s_j|s,a)v_n(s_j)\},$$

$$v^{\pi }(s,\alpha )=p(G_t>\alpha |s).$$

$$Q(s,a,\alpha )=p(G_t>\alpha |s,a).$$

$$v^{{\pi }^{\ast }}(s,\alpha )\ge v^{\pi }(s,\alpha ),\forall s\in S\text{ and }\forall \pi .$$

$$P_s=[P_s(1),...,P_s(K)]\text{ and }{G}_s=[G_s(1),...,G_s(K)]$$

$$v(s,\alpha )=\sum _{k=1}^K{P}_s(k)\cdot \text{mathbbm}1\{G_s(k)>\alpha \},$$

$$P_{s_1}=[p\cdot P_{s_1^{\prime }},(1-p)\cdot P_{s_2^{\prime }})],$$

$$G_{s_1}=[r(s_1^{\prime })+\lambda \cdot G_{s_1^{\prime }},r(s_2^{\prime })+\lambda \cdot G_{s_2^{\prime }}].$$

$$G_{s_1}=[r(s_1^{\prime })+\lambda \cdot G_{s_1^{\prime }}^{ref},r(s_2^{\prime })+\lambda \cdot G_{s_2^{\prime }}^{ref}].$$

$$G_s=[r(s_{j_1})+\lambda \cdot G_{s_{j_1}}^{ref},...,r(s_{j_k})+\lambda \cdot G_{s_{j_k}}^{ref},...],$$

$$P_s=[p(s_{j_1}|s,a)\cdot P_{s_{j_1}},...,p(s_{j_k}|s,a)\cdot P_{s_{j_k}},...],$$

$$Q_n(s,a,\alpha )=\sum _k{P}_{s,a}(k)\cdot 1\{G_s^{ref}(k)>\alpha \}.$$

$$a^{\ast }=\underset{a\in A_s}{\text{arg max }}{Q}_n(s,a,\alpha ),$$

$$v_n(s,\alpha )=Q_n(s,a^{\ast },\alpha ).$$

$$G_{s,a}=[r(s_{j_1})+\lambda \cdot G_{s_{j_1}}^{ref},...,r(s_{j_k})+\lambda \cdot G_{s_{j_k}}^{ref},...],$$

$$\begin{array}{rl}& P_{s,a}^{bin}=[p(s_{j_1}|s,a)P_{s_{j_1}}(k_1)+p(s_{j_2}|s,a)P_{s_{j_2}}(k_2)+\\ & ...,...].\end{array}$$

$$Q^n(s,a,\alpha )=\sum _k{P}_{s,a}^{bin}(k)\cdot 1\{G_s^{ref}(k)>\alpha \},$$

$$\hat{Q}(s,a)=\hat{Q}(s,a)+\gamma {\Delta }_t,$$

$${\Delta }_t=\hat{Q}(s,a)-{\hat{Q}}^{\prime }(s,a)$$

$$\begin{array}{rl}& P_s=P_s+\gamma {\Delta }_t,\end{array}$$

Full text

I Introduction

We consider an agent trying to learn the optimal sequence of actions to be taken in an environment in order to maximize the total amount of reward. This total amount of reward is called the gain. Standard approaches, both in the framework of MDP and reinforcement learning, focus on the expected (average) gain. Consequently, most algorithms in the literature are designed to maximize this expected gain. For instance, all algorithms in the reference books [4] and [6] optimize the expected gain. See Section IV for connections with recent works. As an illustration in the scope of a resource allocation problem, a scheduler (the agent in this case) should decide which entity gets the resource at each time step, see [5] for an example. In the standard approach, the guideline is to minimize the average number of system failures.

However, one may be interested in ensuring that the gain is almost always greater than a given value, i.e., optimizing the outage probability. This is relevant for safety applications where some situations should be avoided with the highest possible probability, even if the average performance is reduced. In the case of a resource allocation problem, it can be relevant to minimize the probability that the number of system failures is greater than a given quantity. In information theory, the outage probability of a communication channel, defined as the probability that a given information rate is not supported, is an important metric.

Consequently, we propose an algorithm, inspired from existing MDP algorithms, which enables to optimize the outage probability. We also explain how this algorithm can be generalized to allow the use of neural networks, instead of storing many values in a table.

II Standard maximum expected gain approach

We consider an infinite-horizon MDP with a discounted sum-reward criterion as presented in [4, Chap. 6], defined by states, actions, transition probabilities, and rewards. The sum-reward criterion, called the gain, is computed as

[TABLE]

where $r_{i}$ is the reward received at each time step $i$ and $0\leq\lambda<1$ the discount.

In general, the objective in this framework is to find a policy $\pi$, i.e., the decision rule to be used at each time step, that maximizes the expected gain $\mathbb{E}[G_{t}]$. Here, the expectation is applied with respect to the randomness in the environment, modelled by transition probabilities between the system states.

Accordingly, the value of a state $s\in S$ obtained with a given policy $\pi$, where $S$ is the set of possible system states, is defined as the expected gain given that the system is in the state $s$ at time $t$:

[TABLE]

Then, a policy $\pi^{*}$ is optimal if

[TABLE]

Under the optimal policy, the value of a state $s$ can be expressed via Bellman equation as

[TABLE]

where $A_{s}$ is the set of allowable actions in state $s$ and $Q(s,a)$, called the $Q$-value, is defined as

[TABLE]

with $p(s_{j}|s,a)$ denoting the transition probability from state $s$ to state $s_{j}$ given action $a$ and the average short-term reward $R(s,a)$ is $R(s,a)=\sum_{j}p(s_{j}|s,a)r(s_{j},s)$, where $r(s_{j},s)$ is the reward obtained when going from state $s$ to state $s_{j}$. Given the $Q$-values, the optimal action in a state $s$ is obtained as

[TABLE]

A standard approach to compute the values $v^{\pi^{*}}(s)$ is to use the value iteration algorithm [6, Chap 4.4]. It consists in computing $v_{n+1}(s)$ at iteration $n+1$, $\forall s\in S$, as

[TABLE]

where $v_{n}(s)$ converges to $v^{\pi^{*}}(s)$ as it is the unique fixed point (see [4] for a proof). This step can be seen as a training phase.

Having the values of $v^{\pi^{*}}(s)$ $\forall s\in S$, the action to be taken in a given state $s$ according to $\pi^{*}$ can be implemented by computing (5) $\forall a\in A_{s}$ and then using (6). We refer to the obtained policy as the maximum expected gain policy.

III Alternative proposed approach

III-A Problem statement

Instead of maximizing the expected gain, we propose to maximize the probability that $G_{t}$ is greater than a given value $\alpha$. Since $p(G_{t}>\alpha)=1-p(G_{t}\leq\alpha)$, this is equivalent to minimizing $p(G_{t}<\alpha)$, commonly called outage probability. This outage probability represents the risk to have a bad system outcome which is essential for safety applications. Therefore, the value of a state $s$ with parameter $\alpha$ is now defined as follows:

[TABLE]

Accordingly, we also define the value of a state with parameter $\alpha$ given an action $a\in A_{s}$:

[TABLE]

The new goal is thus to find a policy $\pi^{*}$ that maximizes the probability that the gain $G_{t}$ is above an arbitrary value $\alpha$, i.e., such that:

[TABLE]

This latter policy $\pi^{*}$ is called the alternative policy.

III-B Example

We consider the recycling robot problem, presented in [6, Chap. 3], as a toy example to illustrate the difference between the two objectives. The problem is the following: A mobile robot running on a battery should collect empty cans. It can be in two battery states $S=\{s_{1}=\text{``low"},s_{2}=\text{``high"}\}$. For both states, the possible actions are $A=\{a_{1}=\text{``search", }a_{2}=\text{``wait" },a_{3}=\text{``recharge" }\}$. With the action “wait”, the robot stays in the same state with probability $p(s_{i}|s_{i},a_{2})=1$ (whatever $i$) and gets reward $r_{wait}$. With the action “search”, the robot goes from state “high” to state “low” with probability $p(s_{1}|s_{2},a_{1})=1-\beta$ and gets reward $r_{search}>r_{wait}$ with probability 1. In the state “low”, it stays in the same state also with probability $\beta$ and gets reward $r_{search}$ in this case, but it gets the negative reward $r_{rescue}$ otherwise and goes back to state “high”. Finally, with the action “recharge”, the robot goes to state “high” with probability $p(s_{2}|s_{i},a_{3})=1$ and gets reward 0.

For the simulations, we consider the following parameters: $r_{rescue}=-1$, $r_{wait}=0.4$, $r_{search}=0.9$, $\beta=0.8$, and the discount $\lambda=0.8$. In this case, the maximum expected gain policy consists in performing the action “search” for both states, i.e., the robot always searches, regardless of the state. We also consider an alternative policy where the robot implements the action “wait” in the state “low”.

With the alternative policy, the expected gain for state “low” $\mathbb{E}[G_{t}|s_{1}]$ is reduced: 2 against 3.18. However, $p(G_{t}>2-\epsilon|s_{1})$, $\epsilon>0$ being a small quantity, is greater with the alternative policy: This can be observed on Figure 1 where we show the empirical complement cumulative density function (CCDF) obtained by simulating both policies. The maximum expected gain strategy is NOT optimal to maximize $p(G_{t}>\alpha|s_{1})$ where $\alpha<2$.

IV Connections with recent relevant works

A relevant fundamental work from the literature is [1]. In a nutshell, they propose to work directly with random variables, and thus distributions, rather than the expected gain. As a result, they consider the distributional Bellman equation as an alternative to the standard Bellman equation: $Z(s,a)=R(s,a)+\lambda Z(s^{\prime},a^{\prime}),$ where $Z$ is the gain random variable (denoted by $G$ in this paper) given action $a$ in state $s$. This leads to a Monte Carlo algorithm (Algorithm 1 in the paper) where atoms and probabilities are tracked in the iteration loop.

The objective in [1] is not the outage probability but still the expected gain. Moreover, we focus on the MDP approach, meaning that we assume the knowledge of the model (i.e., the transition probabilities between the states). In [1], the practical part (Section 4) considers the Monte Carlo approach without the model.

The authors of [1] cover additional cases in a draft book currently under revision [2], including the practical distributional value iteration. As a result, our proposed Algorithm 1 is similar to the “categorical dynamic programming” (Algorithm 5.3 in [2, Chap. 5]). Then, algorithm 2 can be classified as a “risk-sensitive value iteration” (Section 7.7), where we use the outage probability111Only the conditional value at risk and the variance constrained objective are considered rule as greedy policy. We note however that only temporal-difference learning with the Monte Carlo approach is considered, whereas temporal-difference learning without Monte Carlo may be of interest, see Section VIII and Appendix VI-A.

V Proposed algorithm

We first introduce an algorithm to compute $v(s,\alpha)=p(G_{t}>\alpha|s)$ under a given policy (Algorithm 1). This algorithm is then slightly modified to find a policy that maximizes $v(s,\alpha)$ (Algorithm 2).

V-A Computing $v(s,\alpha)$ under a given policy

V-A1 Notion of path to compute $v(s,\alpha)$

In this first subsection, we consider a given series of actions, e.g., established via the maximum expected gain policy. Figure 2 shows a trellis with the transitions between the states at time $t$, $t+1$, and $t+2$, of an arbitrary MDP.

We can define the notion of path in the trellis, corresponding to one possible set of successive (environment) realization starting from a given state. The $k$-th path starting from a state $s$ is defined by two values:

• •

A path probability: $P_{s}(k)$.

• •

A path gain: $G_{s}(k)$.

In the example of Figure 2, assume that the action $a_{1}$ is taken both at time $t$ and $t+1$ (illustrated by the plain lines). The bold lines on the figure show two paths: a path with $P_{s_{2}}(1)=p\cdot(1-p)$ and $G_{s_{2}}(k)=-1+\lambda\cdot 0$, a path with $P_{s_{2}}(2)=p\cdot p$ and $G_{s_{2}}(2)=-1+\lambda\cdot(-1)$.

Let us merge two paths (i.e., add their probability values) if their gain difference is smaller than a some small value $\epsilon$. Consequently, in the discounted infinite-horizon scope there is a finite number of paths with distinct values, say $K$. We denote by

[TABLE]

the vectors representing the probabilities and the gains, respectively, for all paths starting from $s$. As a result, a state $s$ is characterized by the set $\Omega_{s}=\{P_{s},G_{s}\}$. Then, $v(s,\alpha)$ can be computed as

[TABLE]

where $\mathbbm{1}\{\cdot\}$ denotes the indicator function.

V-A2 Recursively computing $v(s,\alpha)$

Let us now consider one section of the trellis between a state $s_{1}$ and its subsequent states (assuming an arbitrary action): $s_{1}^{\prime}$ with probability $p$ and reward222For the sake of simplicity we write $r(s_{1}^{\prime})$ for $r(s_{1},s^{\prime}_{1})$. $r(s_{1}^{\prime})$ and $s_{2}^{\prime}$ with probability $1-p$ and reward $r(s_{2}^{\prime})$, as illustrated on Figure 3. Assume also that $\Omega_{s^{\prime}_{1}}=\{P_{s^{\prime}_{1}},G_{s^{\prime}_{1}}\}$ and $\Omega_{s^{\prime}_{2}}=\{P_{s^{\prime}_{2}},G_{s^{\prime}_{2}}\}$ are known and both vectors in $\Omega_{s^{\prime}_{1}}$ and $\Omega_{s^{\prime}_{2}}$ are of size $K$.

The set $\Omega_{s_{1}}=\{P_{s_{1}},G_{s_{1}}\}$ can be computed from $\Omega_{s^{\prime}_{1}}$ and $\Omega_{s^{\prime}_{2}}$ as follows:

[TABLE]

The main drawback of the above equation333The equation also brings out the main drawback of (11): as the size doubles when moving from one trellis section to the previous one, $K$ is exponential in the trellis depth. is that the size of the two resulting vectors is doubled compared to the ones of $\Omega_{s^{\prime}_{1}}$ and $\Omega_{s^{\prime}_{2}}$.

We propose to adopt a binning strategy to maintain the size of the vectors fixed. It is similar to the above rule where we merge two paths if their gain difference is smaller than some value $\epsilon$. We introduce the vector $G^{ref}_{s}$ whose components represent the center of the bins. The number of bins $K$ (which is different from the number of paths $K$ in (11)), their width, and their center is determined offline. For instance, the value of $G^{ref}_{s_{1}}(K/2)$ can be chosen as $v(s_{1})$. Note that a unique vector $G^{ref}_{s}$, $\forall s\in S$, could also be used to reduce the complexity.

Hence, after computing (13) and (14), if two components of $G_{s_{1}}$ fall in the same bin of $G^{ref}_{s_{1}}$, e.g., the one centered at $G^{ref}_{s_{1}}(k)$, the corresponding probability values are added and the resulting value $P_{s_{1}}(k)$ is stored. To summarize, $G_{s_{1}}$ and $G_{s_{1}}^{ref}$ are used to establish the binning rule, where $G_{s_{1}}$ is itself computed from $G^{ref}_{s^{\prime}_{1}}$ and $G^{ref}_{s_{2}^{\prime}}$ as (instead of (14))

[TABLE]

As a result, we can use (13) and (15), as well as the binning trick, to iteratively approximate $\Omega_{s}$. This is summarized within Algorithm 1.

Since the binning rule is constant, the same probabilities of $P_{s}$ are merged at each iteration. Hence, steps 5 and 6 could be merged by directly computing a vector $P^{bin}_{s}$ of size $K$ where the probability values are added according to the binning rule.

Example of binning rule: On Figure 3, assume that $G_{s_{1}}^{ref}=G_{s^{\prime}_{1}}^{ref}=G_{s^{\prime}_{2}}^{ref}=[1,\ 3]$, $r(s^{\prime}_{1})=2$, $r(s^{\prime}_{2})=0$, and $\lambda=0.8$. Then, (15) yields $G_{s_{1}}=[2.8,\ 4.4,\ 0.8,\ 2.4]$. Applying the binning rule yields $P^{bin}_{s_{1}}=[P_{s_{1}}(3),\ P_{s_{1}}(1)+P_{s_{1}}(2)+P_{s_{1}}(4)].$

Note that $\Omega_{s}$ can also be used to compute the CCDF, as an alternative to the empirical CCDF, without formerly running the algorithm.

V-B Finding a policy optimized for $p(G_{t}<\alpha)$

In the previous subsection, the actions are chosen according to a given policy $\pi$, such as the maximum expected gain policy. We now explain how to proceed to learn actions maximizing $v(s,\alpha)$.

At steps 5-6 of Algorithm 1, $\Omega_{s}$ is computed for only one action $a$ determined by $\pi$. Alternatively, one could compute $\Omega_{s,a}$ for all $a\in A_{s}$. With the obtained vectors at iteration $n$, one can compute

[TABLE]

Then, the action can be chosen as

[TABLE]

and

[TABLE]

As a result, Algorithm 1 is modified to result in Algorithm 2 to find a policy optimized for $p(G_{t}>\alpha)$. Note that steps 5-6 of Algorithm 1 are merged into a unique step 5 where the binning rule is directly applied to get the vector $P_{s,a}^{bin}$, as described at the end of the previous subsection.

The ouput of Algorithm 2 (which can be seen as a training phase similarly to the value iteration algorithm) is $\Omega_{s}$. This can then be used in the inference phase to recover the optimal action to be performed at each state (as $v(s)$ is used to get the action for the maximum expected gain policy, see the end of Section II).

V-C Simulation results on the toy example

Via Figure 1 for the recycling robot example, we observe that the optimal policy for $p(G_{t}>\alpha|s_{1})$ changes if $\alpha$ is greater or smaller than 2. As an example, we run Algorithm 2 with $\alpha=1.8$ and $\alpha=2.2$. In the first case, the CCDF of the policy obtained is the one shown with the blue curve on Figure 1. In the second case, we get the red curve. This yields the expected results, meaning that Algorithm 2 manages to find the optimal strategy.

VI Towards a deep learning extension

VI-A Temporal-difference learning

A famous alternative to the value iteration algorithm is temporal-difference learning, see [6, Chap. 6], where the model is updated based on the difference between two estimates of a state. As an example, the $Q$ learning algorithm relies on this paradigm. Temporal-difference learning also contains the main idea behind deep reinforcement learning algorithms, such as deep $Q$ learning [3], as it enables to produce an error signal to train the neural networks.

Instead of looping over all the states to estimate the $v^{\pi^{*}}(s)$, the algorithm walks from state to state. In the standard implementation using the Monte Carlo approach, the system is in a state $s$ at time $t$ and an action $a$ is chosen by the algorithm. One then gets a reward $r(s,s^{\prime})$ and the new state $s^{\prime}$ of the system at time $t+1$. The estimate $\hat{Q}(s,a)$ of $Q^{\pi^{*}}(s,a)$ is updated as

[TABLE]

instead of (7) with the value iteration algorithm. The quantity $\gamma$ is the learning rate and

[TABLE]

is the error signal, where:

• •

$\hat{Q}^{\prime}(s,a)=r(s,s^{\prime})+\lambda\max_{a^{\prime}}\hat{Q}(s^{\prime},a^{\prime})$ is a first estimate of $Q^{\pi^{*}}(s,a)$ based on the observed reward and subsequent state obtained when taking the action $a$ in state $s$.

• •

$\hat{Q}(s,a)$ is a second estimate of $Q^{\pi^{*}}(s,a)$ obtained via the currently stored value.

Note that $\hat{Q}^{\prime}(s,a)$ can also be computed via (5), i.e., without the Monte Carlo approach but using the model.

In our framework, a similar error signal can be generated with the vector of probabilities, where we use temporal-difference idea but without the Monte Carlo approach as we assume knowledge of the model. For a state $s$ and given a binning rule, $P_{s}$ can be updated as

[TABLE]

where $\Delta_{t}=f(P^{bin}_{s},P_{s})$ is the error signal with:

• •

$P^{bin}_{s}$ is obtained via (22) and (23),

• •

$P_{s}$ is the currently stored value.

The function $f$ could be a distance measure between two distributions such as the KL divergence or the squared norm of the difference of the two vectors. Of course, (26) needs to be normalized at each time step.

The drawback here, compared to standard temporal-difference learning relying on Monte Carlo method (and thus “true” reinforcement learning), is that we still need a model of the environment dynamic (i.e., we need the transition probablities to compute (22)). For an algorithm compliant with the reinforcement learning paradigm, see Algorithm 1 in [1] and Appendix VIII. Alternatively, a neural network could be trained in a Monte Carlo phase to infer the transition probabilities and then used within the algorithm described above.

VI-B With neural networks

The main idea behind deep $Q$ learning consists in using a neural network to compute $v(s)$ or $Q(s,a)$, $\forall s\in S$, and using the error signal $\Delta_{t}$ (or a sum of several error signals) to train the neural network.

We can propose a similar approach where a neural network computes $P_{s}$ and the error signal $\Delta_{t}=f(P^{bin}_{s},P_{s})$ is used for the training.

VII Conclusions

In this paper, we introduced an algorithm to find a policy that maximizes the probability $p(G_{t}>\alpha)$ that the gain $G_{t}$ is higher than a predefined value $\alpha$. This is an alternative to algorithms searching for a policy that maximizes the expected gain. Optimizing with respect to this new criterion $p(G_{t}>\alpha)$ induces computing path gains and probabilities, where a path corresponds to a given series of state transitions. Computing such path metrics is intractable as the number of paths is exponential in the depth of the trellis. As a result, we introduced a recursive calculation method and a binning rule to merge paths having similar gains. While this new algorithm is presented as an extension of the value iteration algorithm, the main principles are not restricted to this paradigm. We show in the last section how these principles can be applied to modify the $Q$ learning and deep $Q$ learning algorithms to optimize the alternative objective. We use temporal-difference learning but without the Monte Carlo approach.

VIII Appendix

We discuss why the Monte Carlo approach seems to be efficient, as reported in [1].

Consider the example of Figure 3, with rewards $r(s^{\prime}_{1})=r(s^{\prime}_{2})=0$. Let $P_{s^{\prime}_{1}}$ and $P_{s^{\prime}_{2}}$ be the vector of probabilities at $s^{\prime}_{1}$ and $s^{\prime}_{2}$ respectively. Let $P^{*}_{s_{1}}=p\cdot P_{s^{\prime}_{1}}+(1-p)\cdot P_{s^{\prime}_{2}}$ be the optimal probability vector to learn at $s_{1}$ via Monte Carlo samples and $P^{model}_{s_{1}}$ an estimation by a model.

In the non-Monte Carlo approach, we have access to $P^{*}_{s_{1}}$ to update $P^{model}_{s_{1}}$. The problem is trivial. In the Monte Carlo approach, the error signal is computed based on a realization $(s,a,s^{\prime}_{i})$. If $s^{\prime}=s^{\prime}_{1}$, the error signal is $f(P^{model}_{s_{1}},P_{s^{\prime}_{1}})$, where $P_{s^{\prime}_{1}}$ acts as the label. If $s^{\prime}=s^{\prime}_{2}$, the error signal is $f(P^{model}_{s_{1}},P_{s^{\prime}_{2}})$, where $P_{s^{\prime}_{2}}$ acts as the label. In the Monte Carlo training process, the learning algorithm gets approximately $p$ times the error $f(P^{model}_{s_{1}},P_{s^{\prime}_{1}})$ and $(1-p)$ times the error $f(P^{model}_{s_{1}},P_{s^{\prime}_{2}})$. Does it make $P^{model}_{s_{1}}$ converge to $P^{*}_{s_{1}}$?

We performed simple simulations, where $P_{s^{\prime}_{1}}$ and $P_{s^{\prime}_{2}}$ are chosen as discrete Gaussians with distinct means and where we train a neural network as follows. We use the gradient of $f(P^{model}_{s_{1}},P_{s^{\prime}_{i}})$ to update the model, based on a dataset containing $p$ labels $P_{s^{\prime}_{1}}$ and $(1-p)$ label $P_{s^{\prime}_{2}}$ (and where the input of the neural network is a constant). The output of the model $P^{model}_{s_{1}}$ converges towards $P^{*}_{s_{1}}$, which explains why the Monte Carlo approach is also efficient.

It is still to be proven that there are no pathological case. Moreover, it takes several gradient steps to converge whereas the correct distribution is found with one step using the model.