Bruno Scherrer
email: bruno.scherrer@inria.fr

Victor Gabillon
email: victor.gabillon@inria.fr

Mohammad Ghavamzadeh
email: mohammad.ghavamzadeh@inria.fr

Matthieu Geist
email: matthieu.geist@supelec.fr

Approximate Modified Policy Iteration

Modified policy iteration (MPI) is a dynamic programming (DP) algorithm that contains the two celebrated policy and value iteration methods. Despite its generality, MPI has not been thoroughly studied, especially its approximation form which is used when the state and/or action spaces are large or infinite. In this paper, we propose three implementations of approximate MPI (AMPI) that are extensions of well-known approximate DP algorithms: fitted-value iteration, fitted-Q iteration, and classification-based policy iteration. We provide error propagation analyses that unify those for approximate policy and value iteration. On the last classification-based implementation, we develop a finite-sample analysis that shows that MPI's main parameter allows to control the balance between the estimation error of the classifier and the overall value function approximation.

Introduction

Modified Policy Iteration (MPI) [START_REF] Puterman | Modified policy iteration algorithms for discounted Markov decision problems[END_REF] is an iterative algorithm to compute the optimal policy and value function of a Markov Decision Process (MDP). Starting from an arbitrary value function v 0 , it generates a sequence of value-policy pairs

π k+1 = G v k (greedy step) (1) v k+1 = (T π k+1 ) m v k (evaluation step) (2)
where G v k is a greedy policy w.r.t. v k , T π k is the Bellman operator associated to the policy π k , and m ≥ 1 is a parameter. MPI generalizes the well-known dynamic programming algorithms Value Iteration (VI) and Policy Iteration (PI) for values m = 1 and m = ∞, respectively. MPI has less computation per iteration than PI (in a way similar to VI), while enjoys the faster convergence of the PI algorithm [START_REF] Puterman | Modified policy iteration algorithms for discounted Markov decision problems[END_REF].

In problems with large state and/or action spaces, approximate versions of VI (AVI) and PI (API) have been the focus of a rich literature (see e.g. [START_REF] Bertsekas | Neuro-Dynamic Programming[END_REF][START_REF] Szepesvári | Reinforcement Learning Algorithms for MDPs[END_REF]. The aim of this paper is to show that, similarly to its exact form, approximate MPI (AMPI) may represent an interesting alternative to AVI and API algorithms.

In this paper, we propose three implementations of AMPI (Sec. 3) that generalize the AVI implementations of [START_REF] Ernst | Tree-based batch mode reinforcement learning[END_REF]; [START_REF] Antos | Fitted Qiteration in continuous action-space MDPs[END_REF]; [START_REF] Munos | Finite-Time Bounds for Fitted Value Iteration[END_REF] and the classification-based API algorithm of [START_REF] Lagoudakis | Reinforcement Learning as Classification: Leveraging Modern Classifiers[END_REF]; [START_REF] Fern | Approximate Policy Iteration with a Policy Language Bias: Solving Relational Markov Decision Processes[END_REF]; [START_REF] Lazaric | Analysis of a Classification-based Policy Iteration Algorithm[END_REF]; [START_REF] Gabillon | Classification-based policy iteration with a critic[END_REF]. We then provide an error propagation analysis of AMPI (Sec. 4), which shows how the L p -norm of its performance loss can be controlled by the error at each iteration of the algorithm. We show that the error propagation analysis of AMPI is more involved than that of AVI and API. This is due to the fact that neither the contraction nor monotonicity arguments, that the error propagation analysis of these two algorithms rely on, hold for AMPI. The analysis of this section unifies those for AVI and API and is applied to the AMPI implementations presented in Sec. 3. We detail the analysis of the classification-based implementation of MPI (CBMPI) of Sec. 3 by providing its finite sample analysis in Sec. 5. Our analysis indicates that the parameter m allows us to balance the estimation error of the classifier with the overall quality of the value approxima-tion. We report some preliminary results of applying CBMPI to standard benchmark problems and comparing it with some existing algorithms in (Scherrer et al., 2012, Appendix G).

Background

We consider a discounted MDP S, A, P, r, γ , where S is a state space, A is a finite action space, P (ds |s, a), for all (s, a), is a probability kernel on S, the reward function r : S × A → R is bounded by R max , and γ ∈ (0, 1) is a discount factor. A deterministic policy is defined as a mapping π : S → A. For a policy π, we may write r π (s) = r s, π(s) and P π (ds |s) = P ds |s, π(s) . The value of policy π in a state s is defined as the expected discounted sum of rewards received starting from state s and following the policy π, i.e.,v π (s) = E ∞ t=0 γ t r π (s t )| s 0 = s, s t+1 ∼ P π (•|s t ) . Similarly, the action-value function of a policy π at a state-action pair (s, a), Q π (s, a), is the expected discounted sum of rewards received starting from state s, taking action a, and then following the policy. Since the rewards are bounded by R max , the values and action-values should be bounded by V max = Q max = R max /(1 -γ). The Bellman operator T π of policy π takes a function f on S as input and returns the function T π f defined as ∀s, [T π f ](s) = E r π (s) + γf (s ) | s ∼ P π (.|s) , or in compact form, T π f = r π + γP π f . It is known that v π is the unique fixed-point of T π . Given a function f on S, we say that a policy π is greedy w.r.t. f , and write it as π = G f , if ∀s, (T π f )(s) = max a (T a f )(s), or equivalently T π f = max π (T π f ). We denote by v * the optimal value function. It is also known that v * is the unique fixed-point of the Bellman optimality operator

T : v → max π T π v = T G(v) v,
and that a policy π * that is greedy w.r.t. v * is optimal and its value satisfies v π * = v * .

Approximate MPI Algorithms

In this section, we describe three approximate MPI (AMPI) algorithms. These algorithms rely on a function space F to approximate value functions, and in the third algorithm, also on a policy space Π to represent greedy policies. In what follows, we describe the iteration k of these iterative algorithms.

AMPI-V

For the first and simplest AMPI algorithm presented in the paper, we assume that the values v k are represented in a function space F ⊆ R |S| . In any state s, the action π k+1 (s) that is greedy w.r.t. v k can be estimated as follows:

π k+1 (s) = arg max a∈A 1 M M j=1 r (j) a + γv k (s (j) a ) , (3)
where ∀a ∈ A and 1 ≤ j ≤ M , r (j) a and s

(j) a are samples of rewards and next states when action a is taken in state s. Thus, approximating the greedy action in a state s requires M |A| samples. The algorithm works as follows. It first samples N states from a distribution µ, i.e., {s (i) } N i=1 ∼ µ. From each sampled state s (i) , it generates a rollout of size m, i.e., s (i) , a

(i) 0 , r (i) 0 , s (i) 1 , . . . , a (i) m-1 , r (i) m-1 , s (i) m , where a (i) t
is the action suggested by π k+1 in state s (i) t , computed using Eq. 3, and r

(i) t and s (i)
t+1 are the reward and next state induced by this choice of action. For each s (i) , we then compute a rollout estimate v k+1 (s

(i) ) = m-1 t=0 γ t r (i) t + γ m v k (s (i) m ), which is an un- biased estimate of T π k+1 m v k (s (i) ). Finally, v k+1
is computed as the best fit in F to these estimates, i.e.,

v k+1 = Fit F s (i) , v k+1 (s (i) ) N i=1
.

Each iteration of AMPI-V requires N rollouts of size m, and in each rollout any of the |A| actions needs M samples to compute Eq. 3. This gives a total of N m(M |A|+1) transition samples. Note that the fitted value iteration algorithm [START_REF] Munos | Finite-Time Bounds for Fitted Value Iteration[END_REF]) is a special case of AMPI-V when m = 1.

AMPI-Q

In AMPI-Q, we replace the value function v : S → R with an action-value function Q : S × A → R. The Bellman operator for a policy π at a state-action pair (s, a) can then be written as

[T π Q](s, a) = E r π (s, a) + γQ(s , π(s ))|s ∼ P (•|s, a) ,
and the greedy operator is defined as

π = G Q ⇔ ∀s π(s) = arg max a∈A Q(s, a).
In AMPI-Q, action-value functions Q k are represented in a function space F ⊆ R |S×A| , and the greedy action w.r.t. Q k at a state s, i.e., π k+1 (s), is computed as

π k+1 (s) ∈ arg max a∈A Q k (s, a). (4)
The evaluation step is similar to that of AMPI-V, with the difference that now we work with stateaction pairs. We sample N state-action pairs from a distribution µ on S × A and build a rollout set

D k = {s (i) } n i=1 , s (i) iid ∼ µ for all states s (i) ∈ D k do Perform a rollout and return v k (s (i) ) end for Construct the rollout set D k = {s (i) } N i=1 , s (i) iid
∼ µ for all states s (i) ∈ D k and actions a ∈ A do for j = 1 to M do Perform a rollout and return

R j k (s (i) , a) end for Q k (s (i) , a) = 1 M M j=1 R j k (s (i) , a) end for • Approximate value function: v k ∈ argmin v∈F L F k ( µ; v) (regression)
• Approximate greedy policy:

π k+1 ∈ argmin π∈Π L Π k ( µ; π) (classification)
end for

Figure 1. The pseudo-code of the CBMPI algorithm.

D k = {(s (i) , a (i) )} N i=1 , (s (i) , a (i) ) ∼ µ. For each (s (i) , a (i) ) ∈ D k , we generate a rollout of size m, i.e., s (i) , a (i) , r (i) 0 , s (i) 1 , a (i) 1 , • • • , s (i) m , a (i)
m , where the first action is a (i) , a (i) t for t ≥ 1 is the action suggested by π k+1 in state s (i) t computed using Eq. 4, and r (i) t and s (i) t+1 are the reward and next state induced by this choice of action. For each (s (i) , a (i) ) ∈ D k , we then compute the rollout estimate

Q k+1 (s (i) , a (i) ) = m-1 t=0 γ t r (i) t + γ m Q k (s (i) m , a (i) m ), which is an unbiased estimate of (T π k+1 ) m Q k (s (i) , a (i) ). Finally, Q k+1 is the best fit to these estimates in F, i.e., Q k+1 = Fit F (s (i) , a (i) ), Q k+1 (s (i) , a (i) ) N i=1
.

Each iteration of AMPI-Q requires N m samples, which is less than that for AMPI-V. However, it uses a hypothesis space on state-action pairs instead of states. Note that the fitted-Q iteration algorithm [START_REF] Ernst | Tree-based batch mode reinforcement learning[END_REF][START_REF] Antos | Fitted Qiteration in continuous action-space MDPs[END_REF] is a special case of AMPI-Q when m = 1.

Classification-Based MPI

The third AMPI algorithm presented in this paper, called classification-based MPI (CBMPI), uses an ex-plicit representation for the policies π k , in addition to the one used for value functions v k . The idea is similar to the classification-based PI algorithms [START_REF] Lagoudakis | Reinforcement Learning as Classification: Leveraging Modern Classifiers[END_REF][START_REF] Fern | Approximate Policy Iteration with a Policy Language Bias: Solving Relational Markov Decision Processes[END_REF][START_REF] Lazaric | Analysis of a Classification-based Policy Iteration Algorithm[END_REF][START_REF] Gabillon | Classification-based policy iteration with a critic[END_REF] in which we search for the greedy policy in a policy space Π (defined by a classifier) instead of computing it from the estimated value or action-value function (like in AMPI-V and AMPI-Q).

In order to describe CBMPI, we first rewrite the MPI formulation (Eqs. 1 and 2) as

v k = (T π k ) m v k-1 (evaluation step) (5) π k+1 = G (T π k ) m v k-1 (greedy step) (6)
Note that in the new formulation both v k and π k+1 are functions of (T π k ) m v k-1 . CBMPI is an approximate version of this new formulation. As described in Fig. 1, CBMPI begins with arbitrary initial policy π 1 ∈ Π and value function v 0 ∈ F.

m-1 , r

(i) m-1 , s (i)
(s (i) ) of (T π k ) m v k-1 (s (i) ) as v k (s (i) ) = m-1 t=0 γ t r (i) t + γ m v k-1 (s (i) m ), (7)
and use it to build a training set

s (i) , v k (s (i) ) n i=1
. This training set is then used by the regressor to compute v k as an estimate of (T π k ) m v k-1 .

The greedy step at iteration k computes the policy π k+1 as the best approximation of G (T π k ) m v k-1 by solving a cost-sensitive classification problem. From the definition of a greedy policy, if π = G (T π k ) m v k-1 , for each s ∈ S, we have

T π (T π k ) m v k-1 (s) = max a∈A T a (T π k ) m v k-1 (s). (8) By defining Q k (s, a) = T a (T π k ) m v k-1 (
s), we may rewrite Eq. 8 as

Q k s, π(s) = max a∈A Q k (s, a). (9)
The cost-sensitive error function used by CBMPI is of the form

L Π π k ,v k-1 (µ; π) = S max a∈A Q k (s, a) -Q k s, π(s) µ(ds).
To simplify the notation we use

L Π k instead of L Π π k ,v k-1 .
To set up this cost-sensitive classification problem, we build a rollout set D k by sampling N states i.i.d. from a distribution µ. For each state s (i) ∈ D k and each action a ∈ A, we build M independent rollouts of size m + 1, i.e.,3

s (i) , a, r (i,j) 0 , s (i,j) 1 , a (i,j) 1
, . . . , a (i,j) m , r (i,j) m , s

(i,j) m+1 M j=1 ,
where for t ≥ 1, a

(i,j) t = π k (s (i,j) t
), and r (i,j) t and s (i,j) t+1 are the reward and next state induced by this choice of action. From these rollouts, we compute an unbiased estimate of

Q k (s (i) , a) as Q k (s (i) , a) = 1 M M j=1 R j k (s (i) , a)
where

R j k (s (i) , a) = m t=0 γ t r (i,j) t + γ m+1 v k-1 (s (i,j) m+1 ).
Given the outcome of the rollouts, CBMPI uses a costsensitive classifier to return a policy π k+1 that minimizes the following empirical error

L Π k ( µ; π) = 1 N N i=1 max a∈A Q k (s (i) , a) -Q k s (i) , π(s (i) ) ,
with the goal of minimizing the true error L Π k (µ; π). Each iteration of CBMPI requires nm+M |A|N (m+1) (or M |A|N (m + 1) in case we reuse the rollouts, see Footnote 3) transition samples. Note that when m tends to ∞, we recover the DPI algorithm proposed and analyzed by [START_REF] Lazaric | Analysis of a Classification-based Policy Iteration Algorithm[END_REF].

Error propagation

In this section, we derive a general formulation for propagation of error through the iterations of an AMPI algorithm. The line of analysis for error propagation is different in VI and PI algorithms. VI analysis is based on the fact that this algorithm computes the fixed point of the Bellman optimality operator, and this operator is a γ-contraction in max-norm [START_REF] Bertsekas | Neuro-Dynamic Programming[END_REF][START_REF] Munos | Performance Bounds in Lp-norm for Approximate Value Iteration[END_REF]. On the other hand, it can be shown that the operator by which PI updates the value from one iteration to the next is not a contraction in max-norm in general. Unfortunately, we can show that the same property holds for MPI when it does not reduce to VI (i.e., m > 1).

Proposition 1. If m > 1, there exists no norm for which the operator that MPI uses to update the values from one iteration to the next is a contraction.

Proof. Consider a deterministic MDP with two states {s 1 , s 2 }, two actions {change, stay}, rewards r(s 1 ) = 0, r(s 2 ) = 1, and transitions P ch (s 2 |s 1 ) = P ch (s 1 |s 2 ) = P st (s 1 |s 1 ) = P st (s 2 |s 2 ) = 1. Consider the following two value functions v = ( , 0) and v = (0, ) with > 0. Their corresponding greedy policies are π = (st, ch) and π = (ch, st), and the next iterates of v and v can be computed as

(T π ) m v = γ m 1 + γ m and (T π ) m v = γ-γ m 1-γ + γ m 1-γ m 1-γ + γ m . Thus, (T π ) m v -(T π ) m v = γ-γ m 1-γ γ-γ m 1-γ while v -v = -.
Since can be arbitrarily small, the norm of (T π ) m v -(T π ) m v can be arbitrarily larger than the norm of v -v as long as m > 1.

We also know that the analysis of PI usually relies on the fact that the sequence of the generated values is non-decreasing [START_REF] Bertsekas | Neuro-Dynamic Programming[END_REF][START_REF] Munos | Error Bounds for Approximate Policy Iteration[END_REF]. Unfortunately, it can easily be shown that for m finite, the value functions generated by MPI may decrease (it suffices to take a very high initial value).

It can be seen from what we just described and Proposition 1 that for m = 1 and ∞, MPI is neither contracting nor non-decreasing, and thus, a new line of proof is needed for the propagation of error in this algorithm.

To study error propagation in AMPI, we introduce an abstract algorithmic model that accounts for potential errors. AMPI starts with an arbitrary value v 0 and at each iteration k ≥ 1 computes the greedy policy w.r.t. v k-1 with some error k , called the greedy step error. Thus, we write the new policy π k as

π k = G k v k-1 . (10)
Eq. 10 means that for any policy π ,

T π v k-1 ≤ T π k v k-1 + k .
AMPI then generates the new value function v k with some error k , called the evaluation step error

v k = (T π k ) m v k-1 + k . ( 11
)
Before showing how these two errors are propagated through the iterations of AMPI, let us first define them in the context of each of the algorithms presented in Section 3 separately.

AMPI-V: k is the error in fitting the value function v k . This error can be further decomposed into two parts: the one related to the approximation power of F and the one due to the finite number of samples/rollouts. k is the error due to using a finite number of samples M for estimating the greedy actions.

AMPI-Q: k = 0 and k is the error in fitting the state-action value function Q k .

CBMPI: This algorithm iterates as follows:

v k = (T π k ) m v k-1 + k π k+1 = G k+1 [(T π k ) m v k-1
] Unfortunately, this does not exactly match with the model described in Eqs. 10 and 11. By introducing the auxiliary variable

w k ∆ = (T π k ) m v k-1 , we have v k = w k + k ,
and thus, we may write

π k+1 = G k+1 [w k ] . ( 12
) Using v k-1 = w k-1 + k-1 , we have w k = (T π k ) m v k-1 = (T π k ) m (w k-1 + k-1 ) = (T π k ) m w k-1 + (γP π k ) m k-1 . (13)
Now, Eqs. 12 and 13 exactly match Eqs. 10 and 11 by replacing v k with w k and k with (γP π k ) m k-1 . The rest of this section is devoted to show how the errors k and k propagate through the iterations of an AMPI algorithm. We only outline the main arguments that will lead to the performance bound of Thm. 1 and report most proofs in [START_REF] Scherrer | Approximate Modified Policy Iteration[END_REF]. We follow the line of analysis developped by [START_REF] Thiery | Performance bound for Approximate Optimistic Policy Iteration[END_REF]. The results are obtained using the following three quantities:

1) The distance between the optimal value function and the value before approximation at the k th iteration:

d k ∆ = v * -(T π k ) m v k-1 = v * -(v k -k ).
2) The shift between the value before approximation and the value of the policy at the k th iteration:

s k ∆ = (T π k ) m v k-1 -v π k = (v k -k ) -v π k .
3) The Bellman residual at the k th iteration:

b k ∆ = v k -T π k+1 v k .
We are interested in finding an upper bound on the

loss l k ∆ = v * -v π k = d k + s k .
To do so, we will upper bound d k and s k , which requires a bound on the Bellman residual b k . More precisely, the core of our analysis is to prove the following point-wise inequalities for our three quantities of interest.

Lemma 1 (Proof in [START_REF] Scherrer | Approximate Modified Policy Iteration[END_REF]

, Ap- pendix A)). Let k ≥ 1, x k ∆ = (I -γP π k ) k + k+1 and y k ∆ = -γP π * k + k+1 . We have: b k ≤ (γP π k ) m b k-1 + x k , d k+1 ≤ γP π * d k + y k + m-1 j=1 (γP π k+1 ) j b k , s k = (γP π k ) m (I -γP π k ) -1 b k-1 .
Since the stochastic kernels are non-negative, the bounds in Lemma 1 indicate that the loss l k will be bounded if the errors k and k are controlled. In fact, if we define as a uniform upper-bound on the errors

| k | and | k |, the first inequality in Lemma 1 implies that b k ≤ O( ),
and as a result, the second and third inequalities gives us d k ≤ O( ) and s k ≤ O( ). This means that the loss will also satisfy l k ≤ O( ).

Our bound for the loss l k is the result of careful expansion and combination of the three inequalities in Lemma 1. Before we state this result, we introduce some notations that will ease our formulation.

Definition 1. For a positive integer n, we define P n as the set of transition kernels that are defined as follows:

1) for any set of n policies {π 1 , . . . , π n }, (γP π1 )(γP π2 ) . . . (γP πn ) ∈ P n , 2) for any α ∈ (0, 1) and (P 1 , P 2 ) ∈ P n × P n , αP 1 + (1 -α)P 2 ∈ P n . Furthermore, we use the somewhat abusive notation Γ n for denoting any element of P n . For example, if we write a transition kernel P as

P = α 1 Γ i + α 2 Γ j Γ k = α 1 Γ i +α 2 Γ j+k ,
it should be read as there exist P 1 ∈ P i , P 2 ∈ P j , P 3 ∈ P k , and P 4 ∈ P k+j such that P = α 1 P 1 + α 2 P 2 P 3 = α 1 P 1 + α 2 P 4 .

Using the notation introduced in Definition 1, we now derive a point-wise bound on the loss.

Lemma 2 (Proof in (Scherrer et al., 2012, Appendix B)). After k iterations, the losses of AMPI-V and AMPI-Q satisfy

l k ≤ 2 k-1 i=1 ∞ j=i Γ j | k-i | + k-1 i=0 ∞ j=i Γ j | k-i | + h(k),
while the loss of CBMPI satisfies

l k ≤ 2 k-2 i=1 ∞ j=i+m Γ j | k-i-1 | + k-1 i=0 ∞ j=i Γ j | k-i | + h(k), where h(k) ∆ = 2 ∞ j=k Γ j |d 0 | or h(k) ∆ = 2 ∞ j=k Γ j |b 0 |.
Remark 1. A close look at the existing point-wise error bounds for AVI (Munos, 2007, Lemma 4.1) and API (Munos, 2003, Corollary 10) shows that they do not consider error in the greedy step (i.e., k = 0) and that they have the following form:

lim sup k→∞ l k ≤ 2 lim sup k→∞ k-1 i=1 ∞ j=i Γ j | k-i |.
This indicates that the bound in Lemma 2 not only unifies the analysis of AVI and API, but it generalizes them to the case of error in the greedy step and to a finite horizon k. Moreover, our bound suggests that the way the errors are propagated in the whole family of algorithms VI/PI/MPI does not depend on m at the level of the abstraction suggested by Definition 1. 4 The next step is to show how the point-wise bound of Lemma 2 can turn to a bound in weighted L p -norm, which for any function f : S → R and any distribution µ on S is defined as f p,µ [START_REF] Munos | Error Bounds for Approximate Policy Iteration[END_REF][START_REF] Munos | Performance Bounds in Lp-norm for Approximate Value Iteration[END_REF]; [START_REF] Munos | Finite-Time Bounds for Fitted Value Iteration[END_REF], and the recent work of [START_REF] Farahmand | Error propagation for approximate policy and value iteration[END_REF], which provides the most refined bounds for API and AVI, show how to do this process through quantities, called concentrability coefficients, that measure how a distribution over states may concentrate through the dynamics of the MDP. We now state a lemma that generalizes the analysis of [START_REF] Farahmand | Error propagation for approximate policy and value iteration[END_REF] to a larger class of concentrability coefficients. We will discuss the potential advantage of this new class in Remark 4. We will also show through the proofs of Thms. 1 and 3, how the result of Lemma 3 provides us with a flexible tool for turning point-wise bounds into L p -norm bounds. Thm. 3 in (Scherrer et al., 2012, Appendix D) provides an alternative bound for the loss of AMPI, which in analogy with the results of [START_REF] Farahmand | Error propagation for approximate policy and value iteration[END_REF] shows that the last iterations have the highest impact on the loss (the influence exponentially decreases towards the initial iterations).

∆ = |f (x)| p µ(dx) 1/p .
Lemma 3 (Proof in [START_REF] Scherrer | Approximate Modified Policy Iteration[END_REF], Appendix C)). Let I and (J i ) i∈I be sets of positive integers, {I 1 , . . . , I n } be a partition of I, and f and (g i ) i∈I be functions satisfying

|f | ≤ i∈I j∈Ji Γ j |g i | = n l=1 i∈I l j∈Ji Γ j |g i |.
Then for all p, q and q such that 1 q + 1 q = 1, and for all distributions ρ and µ, we have 4 Note however that the dependence on m will reappear if we make explicit what is hidden in the terms Γ j .

f p,ρ ≤ n l=1 C q (l) 1/p sup i∈I l g i pq ,µ i∈I l j∈Ji γ j ,
with the following concentrability coefficients

Cq(l) ∆ = i∈I l j∈J i γ j cq(j) i∈I l j∈J i γ j ,
with the Radon-Nikodym derivative based quantity cq(j)

∆ = max π 1 ,••• ,π j d(ρPπ 1 Pπ 2 • • • Pπ j ) dµ q,µ (14)
We now derive a L p -norm bound for the loss of the AMPI algorithm by applying Lemma 3 to the pointwise bound of Lemma 2.

Theorem 1 (Proof in (Scherrer et al., 2012, Appendix D)). Let ρ and µ be distributions over states. Let p, q, and q be such that 1 q + 1 q = 1. After k iterations, the loss of AMPI satisfies

l k p,ρ ≤ 2(γ -γ k ) C 1,k,0 q 1 p (1 -γ) 2 sup 1≤j≤k-1 j pq ,µ (15)
+ (1 -γ k ) C 0,k,0 q 1 p (1 -γ) 2 sup 1≤j≤k j pq ,µ + g(k),
while the loss of CBMPI satisfies

l k p,ρ ≤ 2γ m (γ -γ k-1 ) C 2,k,m q 1 p (1 -γ) 2 sup 1≤j≤k-2 j pq ,µ (16)
+ (1 -γ k ) C 1,k,0 q 1 p (1 -γ) 2 sup 1≤j≤k j pq ,µ + g(k),
where for all q, l, k and d, the concentrability coefficients C l,k,d q are defined as

C l,k,d q ∆ = (1 -γ) 2 γ l -γ k k-1 i=l ∞ j=i γ j cq(j + d),
with c q (j) given by Eq. 14, and g(k) is defined as

g(k) ∆ = 2γ k 1-γ C k,k+1 q 1 p min d 0 pq ,µ , b 0 pq ,µ .
Remark 2. When p tends to infinity, the first bound of Thm. 1 reduces to

l k ∞ ≤ 2(γ -γ k ) (1 -γ) 2 sup 1≤j≤k-1 j ∞ + 1 -γ k (1 -γ) 2 sup 1≤j≤k j ∞ + 2γ k 1 -γ min( d0 ∞, b0 ∞). ( 17
)
When k goes to infinity, Eq. 17 gives us a generalization of the API (m = ∞) bound of Bertsekas & Tsitsiklis (1996, Prop. 6.2), i.e.,

lim sup k→∞ l k ∞ ≤ 2γ sup j j ∞ + sup j j ∞ (1 -γ) 2 .
Moreover, since our point-wise analysis generalizes those of API and AVI (as noted in Remark 1), the L p -bound of Eq. 15 unifies and generalizes those for API [START_REF] Munos | Error Bounds for Approximate Policy Iteration[END_REF] and AVI [START_REF] Munos | Performance Bounds in Lp-norm for Approximate Value Iteration[END_REF]. [START_REF] Canbolat | approximate) iterated successive approximations algorithm for sequential decision processes[END_REF]), this leads to a bound on the loss that is looser than ours. In particular, this does not allow to recover the standard bounds for AVI/API, as we managed to (c.f. Remark 2). Remark 4. We can balance the influence of the concentrability coefficients (the bigger the q, the higher the influence) and the difficulty of controlling the errors (the bigger the q , the greater the difficulty in controlling the L pq -norms) by tuning the parameters q and q , given the condition that 1 q + 1 q = 1. This potential leverage is an improvement over the existing bounds and concentrability results that only consider specific values of these two parameters: q = ∞ and q = 1 in [START_REF] Munos | Performance Bounds in Lp-norm for Approximate Value Iteration[END_REF]; [START_REF] Munos | Finite-Time Bounds for Fitted Value Iteration[END_REF], and q = q = 2 in [START_REF] Farahmand | Error propagation for approximate policy and value iteration[END_REF]. Remark 5. For CBMPI, the parameter m controls the influence of the value function approximator, cancelling it out in the limit when m tends to infinity (see Eq. 16). Assuming a fixed budget of sample transitions, increasing m reduces the number of rollouts used by the classifier and thus worsens its quality; in such a situation, m allows to make a trade-off between the estimation error of the classifier and the overall value function approximation.

Finite-Sample Analysis of CBMPI

In this section, we focus on CBMPI and detail the possible form of the error terms that appear in the bound of Thm. 1. We select CBMPI among the proposed algorithms because its analysis is more general than the others as we need to bound both greedy and evaluation step errors (in some norm), and also because it displays an interesting influence of the parameter m (see Remark 5). We first provide a bound on the greedy step error. From the definition of k for CBMPI (Eq. 12) and the description of the greedy step in CBMPI, we can easily observe that k 1,µ = L Π k-1 (µ; π k ).

Lemma 4 (Proof in (Scherrer et al., 2012, Appendix E)). Let Π be a policy space with finite VCdimension h = V C(Π) and µ be a distribution over the state space S. Let N be the number of states in D k-1 drawn i.i.d. from µ, M be the number of rollouts per state-action pair used in the estimation of Q k-1 , and π k = argmin π∈Π L Π k-1 ( µ, π) be the policy computed at iteration k -1 of CBMPI. Then, for any δ > 0, we have

k 1,µ = L Π k-1 (µ; π k ) ≤ inf π∈Π L Π k-1 (µ; π) + 2( 1 + 2 ),
with probability at least 1 -δ, where

1 (N, δ) = 16Qmax 2 N h log eN h + log 32 δ , 2 (N, M, δ) = 8Qmax 2 M N h log eM N h + log 32 δ .
We now consider the evaluation step error. The evaluation step at iteration k of CBMPI is a regression problem with the target (T π k ) m v k-1 and a training set

s (i) , v k (s (i) ) n i=1
in which the states s (i) are i.i.d. samples from µ and v k (s (i) ) are unbiased estimates of the target computed according to Eq. 7. Different function spaces F (linear or non-linear) may be used to approximate (T π k ) m v k-1 . Here we consider a linear architecture with parameters α ∈ R d and bounded (by L) basis functions {ϕ j } d j=1 , ϕ j ∞ ≤ L. We denote by φ : X → R d , φ(•) = ϕ 1 (•), . . . , ϕ d (•) the feature vector, and by F the linear function space spanned by the features ϕ j , i.e., F = {f α (•) = φ(•) α : α ∈ R d }. Now if we define v k as the truncation (by V max ) of the solution of the above linear regression problem, we may bound the evaluation step error using the following lemma.

Lemma 5 (Proof in (Scherrer et al., 2012, Appendix F)). Consider the linear regression setting described above, then we have

k 2,µ ≤ 4 inf f ∈F (T π k ) m v k-1 -f 2,µ + 1 + 2 ,
with probability at least 1 -δ, where

1(n, δ) = 32Vmax 2 n log 27(12e 2 n) 2(d+1) δ , 2(n, δ) = 24 Vmax + α * 2 • sup x φ(x) 2 2 n log 9 δ ,
and α * is such that f α * is the best approximation (w.r.t. µ) of the target function

(T π k ) m v k-1 in F.
From Lemmas 4 and 5, we have bounds on k 1,µ and k 1,µ ≤ k 2,µ . By a union bound argument, we thus control the r.h.s of Eq. 16 in L 1 norm. In the context of Th. 1, this means p = 1, q = 1 and q = ∞, and we have the following bound for CBMPI:

Theorem 2. Let d = sup g∈F ,π inf π∈Π L Π π ,g (µ; π) and d m = sup g∈F ,π inf f ∈F (T π ) m g -f 2,µ .
With the notations of Th. 1 and Lemmas 4-5, after k iterations, and with probability 1 -δ, the expected loss

E µ [l k ] = l k 1,µ of CBMPI is bounded by 2γ m (γ -γ k-1 )C 2,k,m ∞ (1 -γ) 2 dm + 1(n, δ 2k ) + 2(n, δ 2k ) + (1 -γ k )C 1,k,0 ∞ (1 -γ) 2 d + 1 (N, δ 2k ) + 2 (N, M, δ 2k ) + g(k).
Remark 6. This result leads to a quantitative version of Remark 5. Assume that we have a fixed budget for the actor and the critic B = nm = N M |A|m.

Then, up to constants and logarithmic factors, the bound has the form

l k 1,µ ≤ O γ m d m + m B + d + M |A|m B
. It shows the trade-off in the tuning of m: a big m can make the influence of the overall (approximation and estimation) value error small, but that of the estimation error of the classifier bigger.

Summary and Extensions

In this paper, we studied a DP algorithm, called modified policy iteration (MPI), that despite its generality that contains the celebrated policy and value iteration methods, has not been thoroughly investigated in the literature. We proposed three approximate MPI (AMPI) algorithms that are extensions of the wellknown ADP algorithms: fitted-value iteration, fitted-Q iteration, and classification-based policy iteration.

We reported an error propagation analysis for AMPI that unifies those for approximate policy and value iteration. We also provided a finite-sample analysis for the classification-based implementation of AMPI (CBMPI), whose analysis is more general than the other presented AMPI methods. Our results indicate that the parameter of MPI allows us to control the balance of errors (in value function approximation and estimation of the greedy policy) in the final performance of CBMPI. Although AMPI generalizes the existing AVI and classification-based API algorithms, additional experimental work and careful theoretical analysis are required to obtain a better understanding of the behaviour of its different implementations and their relation to the competitive methods. Extension of CBMPI to problems with continuous action space is another interesting direction to pursue.

Supplementary Material for Approximate Modified Policy Iteration

A. Proof of Lemma 1

Before we start, we recall the following definitions:

b k = v k -T π k+1 v k , d k = v * -(T π k ) m v k-1 = v * -(v k -k ), s k = (T π k ) m v k-1 -v π k = (v k -k ) -v π k . Bounding b k b k = v k -T π k+1 v k = v k -T π k v k + T π k v k -T π k+1 v k (a) ≤ v k -T π k v k + k+1 = v k -k -T π k v k + γP π k k + k -γP π k k + k+1 (b) = v k -k -T π k (v k -k ) + (I -γP π k ) k + k+1 . ( 18
)
Using the definition of x k , i.e.,

x k ∆ = (I -γP π k ) k + k+1 , (19)
we may write Eq. ( 18) as

b k ≤ v k -k -T π k (v k -k ) + x k (c) = (T π k ) m v k-1 -T π k (T π k ) m v k-1 + x k = (T π k ) m v k-1 -(T π k ) m (T π k v k-1 ) + x k = (γP π k ) m (v k-1 -T π k v k-1 ) + x k = (γP π k ) m b k-1 + x k . (20)
(a) From the definition of k+1 , we have ∀π

T π v k ≤ T π k+1 v k + k+1
, thus this inequality holds also for π = π k .

(b) This step is due to the fact that for every v and v , we have

T π k (v + v ) = T π k v + γP π k v . (c) This is from the definition of k , i.e., v k = (T π k ) m v k-1 + k . Bounding d k d k+1 = v * -(T π k+1 ) m v k = T π * v * -T π * v k + T π * v k -T π k+1 v k + T π k+1 v k -(T π k+1 ) m v k (a) ≤ γP π * (v * -v k ) + k+1 + g k+1 = γP π * (v * -v k ) + γP π * k -γP π * k + k+1 + g k+1 (b) = γP π * v * -(v k -k ) + y k + g k+1 = γP π * d k + y k + g k+1 (c) = γP π * d k + y k + m-1 j=1 (γP π k+1 ) j b k . (21)
(a) This step is from the definition of k+1 (see step (a) in bounding b k ) and by defining g k+1 as follows:

g k+1 ∆ = T π k+1 v k -(T π k+1 ) m v k . (22)
(b) This is from the definition of y k , i.e.,

y k ∆ = -γP π * k + k+1 . (23)
(c) This step comes from rewriting g k+1 as

g k+1 = T π k+1 v k -(T π k+1 ) m v k = m-1 j=1 (T π k+1 ) j v k -(T π k+1 ) j+1 v k = m-1 j=1 (T π k+1 ) j v k -(T π k+1 ) j (T π k+1 v k ) = m-1 j=1 (γP π k+1 ) j (v k -T π k+1 v k ) = m-1 j=1 (γP π k+1 ) j b k . (24)
Bounding s k With some slight abuse of notation, we have

v π k = (T π k ) ∞ v k
and thus:

s k = (T π k ) m v k-1 -v π k (a) = (T π k ) m v k-1 -(T π k ) ∞ v k-1 = (T π k ) m v k-1 -(T π k ) m (T π k ) ∞ v k-1 = (γP π k ) m v k-1 -(T π k ) ∞ v k-1 = (γP π k ) m ∞ j=0 (T π k ) j v k-1 -(T π k ) j+1 v k-1 = (γP π k ) m ∞ j=0 (T π k ) j v k-1 -(T π k ) j T π k v k-1 = (γP π k ) m ∞ j=0 (γP π k ) j (v k-1 -T π k v k-1 ) = (γP π k ) m (I -γP π k ) -1 (v k-1 -T π k v k-1 ) = (γP π k ) m (I -γP π k ) -1 b k . ( 25
) (a) For any v, we have v π k = (T π k ) ∞ v. This step follows by setting v = v k-1 , i.e., v π k = (T π k ) ∞ v k-1 .

B. Proof of Lemma 2

We begin by focusing our analysis on AMPI. Here we are interested in bounding the loss

l k = v * -v π k = d k + s k .
By induction, from Eqs. ( 20) and ( 21), we obtain

b k ≤ k i=1 Γ m(k-i) x i + Γ mk b 0 , (26)
d k ≤ k-1 j=0 Γ k-1-j y j + m-1 l=1 Γ l b j + Γ k d 0 . (27)
in which we have used the notation introduced in Definition 1. In Eq. ( 27), we also used the fact that from Eq. ( 24), we may write g k+1 = m-1 j=1 Γ j b k . Moreover, we may rewrite Eq. ( 25) as

s k = Γ m ∞ j=0 Γ j b k-1 = ∞ j=0 Γ m+j b k-1 . (28)
Bounding l k From Eqs. ( 26) and ( 27), we may write

d k ≤ k-1 j=0 Γ k-1-j y j + m-1 l=1 Γ l j i=1 Γ m(j-i) x i + Γ mj b 0 + Γ k d 0 = k i=1 Γ i-1 y k-i + k-1 j=0 m-1 l=1 j i=1 Γ k-1-j+l+m(j-i) x i + z k , (29)
where we used the following definition

z k ∆ = k-1 j=0 m-1 l=1 Γ k-1+l+j(m-1) b 0 + Γ k d 0 = mk-1 i=k Γ i b 0 + Γ k d 0 .
The triple sum involved in Eq. ( 29) may be written as

k-1 j=0 m-1 l=1 j i=1 Γ k-1-j+l+m(j-i) x i = k-1 i=1 k-1 j=i m-1 l=1 Γ k-1+l+j(m-1)-mi x i = k-1 i=1 mk-1 j=mi+k-i Γ j-mi x i = k-1 i=1 m(k-i)-1 j=k-i Γ j x i = k-1 i=1 mi-1 j=i Γ j x k-i . (30)
Using Eq. ( 30), we may write Eq. ( 29) as

d k ≤ k i=1 Γ i-1 y k-i + k-1 i=1 mi-1 j=i Γ j x k-i + z k . (31)
Similarly, from Eqs. ( 28) and ( 26), we have

s k ≤ ∞ j=0 Γ m+j k-1 i=1 Γ m(k-1-i) x i + Γ m(k-1) b 0 = ∞ j=0 k-1 i=1 Γ m+j+m(k-1-i) x i + Γ m+j+m(k-1) b 0 = k-1 i=1 ∞ j=0 Γ j+m(k-i) x i + ∞ j=0 Γ j+mk b 0 = k-1 i=1 ∞ j=0 Γ j+mi x k-i + ∞ j=mk Γ j b 0 = k-1 i=1 ∞ j=mi Γ j x k-i + z k , (32)
where we used the following definition

z k ∆ = ∞ j=mk Γ j b 0 .
Finally, using the bounds in Eqs. ( 31) and (32), we obtain the following bound on the loss

l k ≤ d k + s k ≤ k i=1 Γ i-1 y k-i + k-1 i=1 mi-1 j=i Γ j + ∞ j=mi Γ j x k-i + z k + z k = k i=1 Γ i-1 y k-i + k-1 i=1 ∞ j=i Γ j x k-i + η k , (33)
where we used the following definition

η k ∆ = z k + z k = ∞ j=k Γ j b 0 + Γ k d 0 . ( 34
)
Note that we have the following relation between b 0 and d

0 b 0 = v 0 -T π1 v 0 = v 0 -v * + T π * v * -T π * v 0 + T π * v 0 -T π1 v 0 ≤ (I -γP π * )(-d 0 ) + 1 , (35)
In Eq. ( 35), we used the fact that v * = T π * v * , 0 = 0, and T π * v 0 -T π1 v 0 ≤ 1 (this is because the policy π 1 is 1 -greedy w.r.t. v 0 ). As a result, we may write |η k | either as

|η k | ≤ ∞ j=k Γ j (I -γP π * )|d 0 | + | 1 | + Γ k |d 0 | ≤ ∞ j=k Γ j (I + Γ 1 )|d 0 | + | 1 | + Γ k |d 0 | = 2 ∞ j=k Γ j |d 0 | + ∞ j=k Γ j | 1 |, (36)
or using the fact that from Eq. ( 35), we have d 0 ≤ (I -γP π * ) -1 (-b 0 + 1 ), as

|η k | ≤ ∞ j=k Γ j |b 0 | + Γ k ∞ j=0 (γP π * ) j |b 0 | + | 1 | = ∞ j=k Γ j |b 0 | + Γ k ∞ j=0 Γ j |b 0 | + | 1 | = 2 ∞ j=k Γ j |b 0 | + ∞ j=k Γ j | 1 |. (37)
Now, using the definitions of x k and y k in Eqs. ( 19) and ( 23), the bound on |η k | in Eq. ( 36) or (37), and the fact that 0 = 0, we obtain

|l k | ≤ k i=1 Γ i-1 Γ 1 | k-i | + | k-i+1 | + k-1 i=1 ∞ j=i Γ j (I + Γ 1 )| k-i | + | k-i+1 | + |η k | = k-1 i=1 Γ i + ∞ j=i (Γ j + Γ j+1 ) | k-i | + Γ k | 0 | + k-1 i=1 Γ i-1 + ∞ j=i Γ j | k-i+1 | + Γ k-1 | 1 | + ∞ j=k Γ j | 1 | + h(k) = 2 k-1 i=1 ∞ j=i Γ j | k-i | + k-1 i=1 ∞ j=i-1 Γ j | k-i+1 | + ∞ j=k-1 Γ j | 1 | + h(k) = 2 k-1 i=1 ∞ j=i Γ j | k-i | + k-1 i=0 ∞ j=i Γ j | k-i | + h(k), (38)
where we used the following definition

h(k) ∆ = 2 ∞ j=k Γ j |d 0 |, or h(k) ∆ = 2 ∞ j=k Γ j |b 0 |.
We end this proof by adapting the error propagation to CBMPI. As expressed by Eqs. 12 and 13 in Sec. 4, an analysis of CBMPI can be deduced from that we have just done by replacing v k with the auxiliary variable

w k = (T π k ) m v k-1 and k with (γP π k ) m k-1 = Γ m k-1 .
Therefore, using the fact that 0 = 0, we can rewrite the bound of Eq. 38 for CBMPI as follows:

l k ≤ 2 k-1 i=1 ∞ j=i Γ j+m | k-i-1 | + k-1 i=0 ∞ j=i Γ j | k-i | + h(k) = 2 k-2 i=1 ∞ j=m+i Γ j | k-i-1 | + k-1 i=0 ∞ j=i Γ j | k-i | + h(k). (39)
C. Proof of Lemma 3

For any integer t and vector z, the definition of Γ t and the Hölder's inequality imply that ρΓ t |z| = Γ t |z| 1,ρ ≤ γ t c q (t) z q ,µ = γ t c q (t) µ|z| q 1 q .

(40)

We define

K ∆ = n l=1 ξ l   i∈I l j∈Ji γ j   ,
where {ξ l } n l=1 is a set of non-negative numbers that we will specify later. We now have

f p p,ρ = ρ|f | p ≤ K p ρ n l=1 i∈I l j∈Ji Γ j |g i | K p = K p ρ   n l=1 ξ l i∈I l j∈Ji Γ j |gi| ξ l K   p (a) ≤ K p ρ n l=1 ξ l i∈I l j∈Ji Γ j |gi| ξ l p K = K p n l=1 ξ l i∈I l j∈Ji ρΓ j |gi| ξ l p K (b) ≤ K p n l=1 ξ l i∈I l j∈Ji γ j c q (j) µ |gi| ξ l pq 1 q K = K p n l=1 ξ l i∈I l j∈Ji γ j c q (j) gi pq ,µ ξ l p K ≤ K p n l=1 ξ l i∈I l j∈Ji γ j c q (j) sup i∈I l gi pq ,µ ξ l p K (c) = K p n l=1 ξ l i∈I l j∈Ji γ j C q (l) sup i∈I l gi pq ,µ ξ l p K ,
where (a) results from Jensen's inequality, (b) from Eq. 40, and (c) from the definition of C q (l). Now, by setting ξ l = C q (l) 1/p sup i∈I l g i pq ,µ , we obtain

f p p,ρ ≤ K p n l=1 ξ l i∈I l j∈Ji γ j K = K p ,
where the last step follows from the definition of K.

D. Proof of Theorem 1 & other Bounds on the Loss

Proof. We only detail the proof for AMPI (the proof being similar for CBMPI). We define I = {1, 2, • • • , 2k}, the partition I = {I 1 , I 2 , I 3 } as I 1 = {1, . . . , k -1}, I 2 = {k, . . . , 2k -1}, and I 3 = {2k}, and for each i ∈ I

g i =    2 k-i if 1 ≤ i ≤ k -1, k-(i-k) if k ≤ i ≤ 2k -1, 2d 0 (or 2b 0 ) if i = 2k, and J i =    {i, i + 1, • • • } if 1 ≤ i ≤ k -1, {i -k, i -k + 1, • • • } if k ≤ i ≤ 2k -1, {k, k + 1, • • • } if i = 2k.
Note that here we have divided the terms in the point-wise bound of Lemma 2 into three groups: the evaluation error terms { j } k-1 j=1 , the greedy step error terms { j } k j=1 , and finally the residual term h(k). With the above definitions and the fact that the loss l k is non-negative, Lemma 2 may be rewritten as

|l k | ≤ 3 l=1 i∈I l j∈Ji Γ j |g i |.
The result follows by applying Lemma 3 and noticing that

k-1 i=i0 ∞ j=i γ j = γ i 0 -γ k (1-γ) 2 .
Here in oder to show the flexibility of Lemma 3, we group the terms differently and derive an alternative L pbound for the loss of AMPI and CBMPI. In analogy with the results of [START_REF] Farahmand | Error propagation for approximate policy and value iteration[END_REF], this new bound shows that the last iterations have the highest influence on the loss (the influence exponentially decreases towards the initial iterations).

Theorem 3. With the notations of Theorem 1, after k iterations, the loss of AMPI satisfies

l k p,ρ ≤ 2 k-1 i=1 γ i 1 -γ C i,i+1 q 1 p k-i pq ,µ + k-1 i=0 γ i 1 -γ C i,i+1 q 1 p k-i pq ,µ + g(k).
while the loss of CBMPI satisfies

l k p,ρ ≤ 2γ m k-2 i=1 γ i 1 -γ C i,i+1 q 1 p k-i-1 pq ,µ + k-1 i=0 γ i 1 -γ C i,i+1 q 1 p k-i pq ,µ + g(k).
Proof. Again, we only detail the proof for AMPI (the proof being similar for CBMPI). We define I, (g i ) and (J i ) as in the proof of Theorem 1. We then make as many groups as terms, i.e., for each n ∈ {1, 2, . . . , 2k -1}, we define I n = {n}. The result follows by application of Lemma 3.

E. Proof of Lemma 4

The proof of this lemma is similar to the proof of Theorem 1 in [START_REF] Lazaric | Analysis of a Classification-based Policy Iteration Algorithm[END_REF]. Before stating the proof, we report the following two lemmas that are used in the proof.

Lemma 6. Let Π be a policy space with finite VC-dimension h = V C(Π) < ∞ and N be the number of states in the rollout set D k-1 drawn i.i.d. from the state distribution µ. Then we have

P D k-1 sup π∈Π L Π k-1 ( µ; π) -L Π k-1 (µ; π) > ≤ δ , with = 16Q max 2 N h log eN h + log 8 δ .
Proof. This is a restatement of Lemma 1 in [START_REF] Lazaric | Analysis of a Classification-based Policy Iteration Algorithm[END_REF].

Lemma 7. Let Π be a policy space with finite VC-dimension h = V C(Π) < ∞ and s (1) , . . . , s (N ) be an arbitrary sequence of states. At each state we simulate M independent rollouts of the form , then we have

P   sup π∈Π 1 N N i=1 1 M M j=1 R j k-1 s (i,j) , π(s (i,j) ) - 1 N N i=1 Q k-1 s (i,j) , π(s (i,j) ) >   ≤ δ , with = 8Q max 2 M N h log eM N h + log 8 δ .
Proof. The proof is similar to the one for Lemma 6.

Proof. (Lemma 4) Let a * (•) = argmax a∈A Q k-1 (•, a) be the greedy action. To simplify the notation, we remove the dependency of a * on states and use a * instead of a * (x i ) in the following. We prove the following series of inequalities:

L Π k-1 (µ; π k ) (a) ≤ L Π k-1 ( µ; π k ) + 1 w.p. 1 -δ = 1 N N i=1 Q k-1 (x i , a * ) -Q k-1 x i , π k (x i ) + 1 (b) ≤ 1 N N i=1 Q k-1 (x i , a * ) -Q k-1 x i , π k (x i ) + 1 + 2 w.p. 1 -2δ (c) ≤ 1 N N i=1 Q k-1 (x i , a * ) -Q k-1 x i , π * (x i ) + 1 + 2 ≤ 1 N N i=1 Q k-1 (x i , a * ) -Q k-1 x i , π * (x i ) + 1 + 2 2 w.p. 1 -3δ = L Π k-1 ( µ; π * ) + 1 + 2 2 ≤ L Π k-1 (µ; π * ) + 2( 1 + 2 ) w.p. 1 -4δ = inf π∈Π L Π k-1 (µ; π) + 2( 1 + 2 ).
The statement of the theorem is obtained by δ = δ/4.

N i=1 Q k-1 s (i) , π(s (i) ) - 1 N N i=1 Q k-1 s (i) , π(s (i) )
using Lemma 7.

(c) From the definition of π k in CBMPI, we have

π k = argmin π∈Π L Π k-1 ( µ; π) = argmax π∈Π 1 N N i=1 Q k-1 s (i) , π(s (i) ) , thus, -1/N N i=1 Q k-1 s (i) , π k (s (i)

F. Proof of Lemma 5

Let us define two n-dimensional vectors z = (T π k ) m v k-1 (s (1) ), . . . , (T π k ) m v k-1 (s (n) ) and y = v k (s (1) ), . . . , v k (s (n) ) and their orthogonal projections onto the vector space F n as z = Πz and y = Πy = v k (s (1) ), . . . , v k (s (n) ) , where v k is the result of linear regression and its truncation (by V max ) is v k , i.e., v k = T( v k ) (see Figure 2). What we are interested is to find a bound on the regression error z -y (the difference between the target function z and the result of the regression y). We may decompose this error as

z -y n ≤ z -y n + z -z n = ξ n + z -z n , (41)
where ξ = z -y is the projected noise (estimation error) ξ = Πξ, with the noise vector ξ = z -y defined as

ξ i = (T π k ) m v k-1 (s (i) ) -v k (s (i)
). It is easy to see that noise is zero mean, i.e., E[ξ i ] = 0 and is bounded by 2V max , i.e., |ξ i | ≤ 2V max . We may write the estimation error as

z -y 2 n = ξ 2 n = ξ, ξ = ξ, ξ ,
where the last equality follows from the fact that ξ is the orthogonal projection of ξ. Since ξ ∈ F n , let f α ∈ F be any function whose values at {s (i) } n i=1 equals to {ξ i } n i=1 . By application of a variation of Pollard's inequality (Györfi et al., 2002), we obtain

ξ, ξ = 1 n n i=1 ξ i f α (s (i) ) ≤ 4V max ξ n 2 n log 3(9e 2 n) d+1 δ ,
with probability at least 1 -δ . Thus, we have

z -y n = ξ n ≤ 4V max 2 n log 3(9e 2 n) d+1 δ . (42)
From Eqs. 41 and 42, we have

(T π k ) m v k-1 -v k µ ≤ (T π k ) m v k-1 -Π(T π k ) m v k-1 µ + 4V max 2 n log 3(9e 2 n) d+1 δ , ( 43
)
where µ is the empirical norm induced from the n i.i.d. samples from µ. Now in order to obtain a random design bound, we first define f α * ∈ F as f α * (s (i) ) = Π(T π k ) m v k-1 (s (i) ), and then define f α * = Π(T π k ) m v k-1 that is the best approximation (w.r.t. µ) of the target function (T π k ) m v k-1 in F. Since f α * is the minimizer of the empirical loss, any function in F different than f α * has a bigger empirical loss, thus we have

f α * -(T π k ) m v k-1 µ ≤ f α * -(T π k ) m v k-1 µ ≤ 2 f α * -(T π k ) m v k-1 µ
at the same time, a large enough rollout sets.

Figure 3 shows the learning results in MC with budget B = 200. On the left panel, the function space is rich enough to approximate v * . Therefore LSPI has almost optimal results (about 80 steps to reach the goal). On the other hand, DPI achieves a poor performance of about 150 steps, which is obtained by setting m = 12 and N = 5. We also report the performance of CBMPI for different values of m and p. When p is large enough, the value function approximation becomes accurate enough so that the best solution is to have m = 1. This both corresponds to rollouts built almost entirely on the basis of the approximated value function and to a large number of states in the training set N . For m = 1 and p ≈ 0.8, CBMPI achieves a slightly better performance than LSPI.

In the next experiment, we show that CBMPI is able to outperform both DPI and LSPI when F has a lower accuracy. The results are reported on the right panel of Figure 3. The performance of LSPI now worsens to 190 steps. Simultaneously one can notice m = 1 is no longer the best choice for CBMPI. Indeed in the case where m = 1, CBMPI becomes an approximated version of the value iteration algorithm relying on a function space not rich enough to approximate v * . Notice that relying on this space is still better than setting the value function to zero which is the case in DPI. Therefore, we notice an improvement of CBMPI over DPI for m = 4 which trade-off between the estimates of the value function and the rewards collected by the rollouts. Combining those two, CBMPI also improves upon LSPI.

( a )

 a This follows from Lemma 6. (b) Here we introduce the estimated action-value function Q k-1 by bounding sup π∈Π 1 N

  ) can be maximized by replacing π k with any other policy, particularly withπ * = argmin π∈Π S max a∈A Q k-1 (s, a) -Q k-1 s, π(s) µ(ds).

Figure 2 .

 2 Figure 2. The vectors used in the proof.

1

  At each iteration k, a new value function v k is built as the best approximation of the m-step Bellman operator (T π k ) m v k-1 in F (evaluation step). This is done by solving a regression problem whose target function is (T π k ) m v k-1 . To set up the regression problem, we build a rollout set D k by sampling n states i.i.d. from a distribution µ. 2 For each state s (i) ∈ D k , we generate a rollout s (i) , a

  ) bounds the norm of the distance v * -v k while we bound the loss v * -v π k . If we derive a bound on the loss (using e.g., Th. 1 in

	Remark 3. Canbolat & Rothblum (2012) recently
	(and independently) developped an analysis of an ap-
	proximate form of MPI. Also, as mentionned, the proof
	technique that we used is based on that of Thiery &
	Scherrer (2010). While Canbolat & Rothblum (2012)
	only consider the error in the greedy step and Thiery
	& Scherrer (2010) that in the value update, our work is
	more general in that we consider both sources of error
	-this is required for the analysis of CBMPI. Thiery
	& Scherrer (2010) and Canbolat & Rothblum (2012)
	provide bounds when the errors are controlled in max-
	norm, while we consider the more general L p -norm.
	At a more technical level, Th. 2 in (Canbolat & Roth-
	blum, 2012

Note that the function space F and policy space Π are automatically defined by the choice of the regressor and classifier, respectively.

Here we used the same sampling distribution µ for both regressor and classifier, but in general different distributions may be used for these two components.

We may implement CBMPI more sample efficient by reusing the rollouts generated for the greedy step in the evaluation step.

with probability at least 1 -δ , where the second inequality is the application of a variation of Theorem 11.2 in the book by Györfi et al., (2002) with

Similarly, we can write the left-hand-side of Equation 43as

with probability at least 1 -δ , where Λ(n, d, δ ) = 2(d + 1) log n + log e δ + log 9(12e) 2(d+1) . Putting together Equations 43, 44, and 45 and using the fact that T( v k ) = v k , we obtain

The result follows by setting δ = 3δ and some simplification. Critic ratio (p) Averaged steps to the goal q LSPI q q q q q DPI Values of m in CBMPI Critic ratio (p) Averaged steps to the goal q LSPI q q q q q DPI Values of m in CBMPI

G. Experimental Results

In this section, we report the empirical evaluation of CBMPI and compare it to DPI and LSPI. In the experiments, we show that CBMPI, by combining policy and value function approximation, can improve over DPI and LSPI. In these experiments, we are using the same setting as in [START_REF] Gabillon | Classification-based policy iteration with a critic[END_REF] to facilitate the comparison.

G.1. Setting

We consider the mountain car (MC) problem with its standard formulation in which the action noise is bounded in [-1, 1] and γ = 0.99. The value function is approximated using a linear space spanned by a set of radial basis functions (RBFs) evenly distributed over the state space.

Each CBMPI-based algorithm is run with the same fixed budget B per iteration. CBMPI splits the budget into a rollout budget B R = B(1 -p) used to build the training set of the greedy step and a critic budget B C = Bp used to build the training set of the evaluation step , where p ∈ (0, 1) is the critic ratio. The rollout budget is divided into M rollouts of length m for each action in A and each state in the rollout set D , i.e., B R = mM N |A|. The critic budget is divided into one rollout of length m for each action in A and each state in the rollout set D, i.e., B C = mn|A|.

In Fig. 3, we report the performance of DPI, CBMPI, and LSPI. In MC, the performance is evaluated as the number of steps-to-go with a maximum of 300. The results are averaged over 1000 runs. We report the performance of DPI and LSPI at p = 0 and p = 1, respectively. DPI can be seen as a special case of CBMPI where p = 0. We tested the performance of DPI and CBMPI on a wide range of parameters (m, M, N, n) but we only report their performance for the best choice of M (M = 1 was the best choice in all the experiments) and different values of m.

G.2. Experiments

As discussed in Remark 5, the parameter m balances between the error in evaluating the value function and the error in evaluating the policy. The value function approximation error tends to zero for large values of m. Although this would suggest to have large values for m, the size of the rollout sets would correspondingly decrease as N = O(B/m) and n = O(B/m), thus decreasing the accuracy of both the regression and classification problems. This leads to a trade-off between long rollouts and the number of states in the rollout sets. The solution to this trade-off strictly depends on the capacity of the value function space F. A rich value function space would lead to solve the trade-off for small values of m. On the other hand, when the value function space is poor, or as in the DPI case, m should be selected in a way to guarantee a sufficient number of informative rollouts, and