Next Article in Journal
Collaboration of Large and Small Models for Event Type Discovery in Completely Open Domains
Previous Article in Journal
Robust Negative Binomial Regression via the Kibria–Lukman Strategy: Methodology and Application
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

On Convergence Rate of MRetrace

1
Jiangsu Key Laboratory of Big Data Security & Intelligent Processing, Nanjing University of Posts and Telecommunications, Nanjing 210023, China
2
College of Electronic Engineering, National University of Defense Technology, Changsha 410073, China
3
Science and Technology on Information Systems Engineering Laboratory, National University of Defense Technology, Changsha 410073, China
*
Author to whom correspondence should be addressed.
Mathematics 2024, 12(18), 2930; https://doi.org/10.3390/math12182930
Submission received: 2 August 2024 / Revised: 15 September 2024 / Accepted: 16 September 2024 / Published: 20 September 2024
(This article belongs to the Section Mathematics and Computer Science)

Abstract

:
Off-policy is a key setting for reinforcement learning algorithms. In recent years, the stability of off-policy learning for value-based reinforcement learning has been guaranteed even when combined with linear function approximation and bootstrapping. Convergence rate analysis is currently a hot topic. However, the convergence rates of learning algorithms vary, and analyzing the reasons behind this remains an open problem. In this paper, we propose an essentially simplified version of a convergence rate to generate general off-policy temporal difference learning algorithms. We emphasize that the primary determinant influencing convergence rate is the minimum eigenvalue of the key matrix. Furthermore, we conduct a comparative analysis of the influencing factor across various off-policy learning algorithms in diverse numerical scenarios. The experimental findings validate the proposed determinant, which serves as a benchmark for the design of more efficient learning algorithms.

1. Introduction

Off-policy learning generates experience data by a behavior policy and learns a different target policy. Off-policy TD learning with a linear function approximation may diverge in counterexamples known as “the deadly triad” [1]. The fundamental reason is that the key matrix of off-policy TD is not guaranteed to be positive definite [2]. In the recent 30 years, the main research focused on the convergence guarantee of off-policy algorithms via the construction of positive definite matrices, e.g., Bellman residual (BR) [3], gradient temporal difference (GTD) [4], fast gradient temporal difference (GTD2) and TD with gradient correction (TDC) [5], emphatic TD (ETD) [2], and modified Retrace (MRetrace) [6].
Recently, due to the guarantee of convergence, more research has paid attention to the convergence rate analysis of reinforcement learning algorithms. Dalal et al. [7] proposed convergence rates both in expectation and with a high probability for one-timescale temporal difference learning algorithms. Dalal et al. [8], Gupta et al. [9], Xu et al. [10], and Dalal et al. [11] obtained convergence rates with a high probability for two-timescale temporal difference learning algorithms. Durmus et al. [12] proposed tight high-probability bounds for linear stochastic approximation with a fixed step size. For control settings, Xu and Liang [13] proposed convergence rates for Greedy-GQ. Zhang et al. [14] proposed convergence rates for projected SARSA. Wang et al. [15] proposed convergence rates with a high probability for distributionally robust Q-learning.
However, the above analysis did not answer the following questions: Which of these algorithms is faster? Which one should we choose? The purpose of this paper is to give an intuitive comparison of the convergence rate.
Our contributions: (1) We propose a simplified version of the expected convergence rate theorem. (2) We analyze the core elements of the convergence rates by assuming the same settings for each algorithm, and we find that the main factor affecting convergence rate is the minimum eigenvalue of the key matrix. (3) We calculate core elements of different temporal difference learning algorithms for several environmental examples and validate by experimental studies.

2. Background

This section introduces MDP and reinforcement learning algorithms with their key matrices.

2.1. Markov Decision Process

Consider a discounted Markov decision process S , A , R , T , γ , where S is a state space, | S | = n , A is an action space, T : S × A × S [ 0 , 1 ] is a transition function, R : S × A × S R is a reward function, and γ [ 0 , 1 ) is a discount factor. The state value function is
V π ( s ) = E π t = 0 γ t r t | s 0 = s ,
where r t is an immediate reward, and π is a policy used to select action a in state s with a probability π ( a | s ) . The value function is approximated with a linear function, as follows:
V ( s ) V θ ( s ) = θ ϕ ( s ) = i = 1 m θ i ϕ i ( s ) ,
where θ is the weight vector, and ϕ ( s ) is the feature vector of state s. This paper is concerned with off-policy learning, where a different behavior policy μ generates experiences s t , a t , r t + 1 , s t + 1 , a t + 1 .

2.2. Learning Algorithms and Their Key Matrices

Learning algorithms and their key matrices are summarized in Table 1.

2.2.1. Off-Policy TD

The update rule of off-policy TD [2] is as follows:
θ t + 1 = ˙ θ t + ρ t α t ( r t + 1 + γ θ t ϕ t + 1 θ t ϕ t ) ϕ t = θ t + α t ρ t r t + 1 ϕ t ρ t ϕ t ( ϕ t γ ϕ t + 1 ) θ t = θ t + α t b off , t A off , t θ t ,
Its key matrix is
A off = lim t E [ A off , t ] = lim t E μ ρ t ϕ t ( ϕ t γ ϕ t + 1 ) = s d μ ( s ) E μ ρ t ϕ t ( ϕ t γ ϕ t + 1 ) | S t = s = s d μ ( s ) a μ ( a | s ) s T ( s , a , s ) π ( a | s ) μ ( a | s ) ϕ ( s ) ϕ ( s ) γ ϕ ( s ) = s d μ ( s ) ϕ ( s ) ( ϕ ( s ) γ a π ( a | s ) s T ( s , a , s ) ϕ ( s ) ) = s d μ ( s ) ϕ ( s ) ( ϕ ( s ) γ s [ P π ] s s ϕ ( s ) ) = Φ D μ ( I γ P π ) Φ ,
b off = lim t E [ b off , t ] = lim t E μ ρ t r t + 1 ϕ t = s d μ ( s ) E μ ρ t r t + 1 ϕ t | S t = s = s d μ ( s ) a μ ( a | s ) π ( a | s ) μ ( a | s ) r t + 1 ϕ ( s ) = s d μ ( s ) ϕ ( s ) a π ( a | s ) s T ( s , a , s ) R ( s , a , s ) = Φ D μ r π ,
where r π is an expected reward vector under policy π with each component being
r π ( s ) = a s π ( a | s ) R ( s , a , s ) .

2.2.2. Retrace(0)

The update rule of Retrace(0) [16] is as follows:
θ t + 1 = ˙ θ t + c t α t r t + 1 + γ θ t E π [ ϕ t + 1 ] θ t ϕ t ϕ t = θ t + α t c t r t + 1 ϕ t c t ϕ t ( ϕ t γ E π [ ϕ t + 1 ] ) θ t = θ t + α t b Retrace ( 0 ) , t A Retrace ( 0 ) , t θ t ,
where c t = min ( 1 , ρ t ) , E π [ ϕ t + 1 ] = a π ( a | s t + 1 ) ϕ ( s t + 1 ) . The key matrix of the expected Retrace’s update (7) is
A Retrace ( 0 ) = lim t E [ A Retrace ( 0 ) , t ] = lim t E μ c t ϕ t ( ϕ t γ E π [ ϕ t + 1 ] ) = s d μ ( s ) E μ c t ϕ ( s ) ( ϕ ( s ) γ E π [ ϕ ( s ) ] ) = s d μ ( s ) ϕ ( s ) a μ ( a | s ) min 1 , π ( a | s ) μ ( a | s ) ϕ ( s ) γ E π [ ϕ ( s ) ] = s d μ ( s ) ϕ ( s ) a min ( μ ( a | s ) , π ( a | s ) ) ϕ ( s ) γ s [ P π ] s s ϕ ( s ) = Φ D μ D c ( I γ P π ) Φ ,
where D c is the n × n diagonal matrix with d c on its diagonal, and each component of d c is
d c ( s ) = a min ( μ ( a | s ) , π ( a | s ) ) .
b Retrace ( 0 ) = lim t E [ b Retrace ( 0 ) , t ] = lim t E μ c t r t + 1 ϕ t = s d μ ( s ) E μ c t r t + 1 ϕ t | S t = s = s d μ ( s ) a μ ( a | s ) min 1 , π ( a | s ) μ ( a | s ) r t + 1 ϕ ( s ) = s d μ ( s ) ϕ ( s ) a min μ ( a | s ) , π ( a | s ) s T ( s , a , s ) R ( s , a , s ) = Φ D μ r c ,
where r c = a min μ ( a | s ) , π ( a | s ) s T ( s , a , s ) R ( s , a , s ) .

2.2.3. Naive Bellman Residual

The update rule of the naive Bellman residual [3] is as follows:
θ t + 1 = ˙ θ t + ρ t α t ( r t + 1 + γ θ t ϕ t + 1 θ t ϕ t ) ( ϕ t γ E π [ ϕ t + 1 ] ) = θ t + α t ρ t r t + 1 ( ϕ t γ ϕ t + 1 ) ρ t ( ϕ t γ ϕ t + 1 ) ( ϕ t γ E π [ ϕ t + 1 ] ) θ t = θ t + α t b BR , t A BR , t θ t ,
Its key matrix is
A BR = lim t E [ A BR , t ] = lim t E μ ρ t ( ϕ t γ E π [ ϕ t + 1 ] ) ( ϕ t γ ϕ t + 1 ) = s d μ ( s ) E μ ρ t ( ϕ t γ E π [ ϕ t + 1 ] ) ( ϕ t γ ϕ t + 1 ) | S t = s = s d μ ( s ) a μ ( a | s ) s T ( s , a , s ) π ( a | s ) μ ( a | s ) ( ϕ ( s ) γ E π [ ϕ ( s ) ] ) ϕ ( s ) γ ϕ ( s ) = s d μ ( s ) a s T ( s , a , s ) π ( a | s ) ( ϕ ( s ) γ E π [ ϕ ( s ) ] ) ( ϕ ( s ) γ ϕ ( s ) ) = s d μ ( s ) ( ϕ ( s ) γ E π [ ϕ ( s ) ] ) ( ϕ ( s ) γ a π ( a | s ) s T ( s , a , s ) ϕ ( s ) ) = s d μ ( s ) ( ϕ ( s ) γ E π [ ϕ ( s ) ] ) ( ϕ ( s ) γ s [ P π ] s s ϕ ( s ) ) = Φ ( I γ P π ) D μ ( I γ P π ) Φ ,
b BR = lim t E [ b BR , t ] = lim t E μ ρ t r t + 1 ( ϕ t γ E π [ ϕ t + 1 ] ) = s d μ ( s ) E μ ρ t r t + 1 ( ϕ t γ E π [ ϕ t + 1 ] ) | S t = s = s d μ ( s ) a μ ( a | s ) π ( a | s ) μ ( a | s ) r t + 1 ( ϕ ( s ) γ E π [ ϕ ( s ) ] ) ) = s d μ ( s ) ( ϕ ( s ) γ E π [ ϕ ( s ) ] ) ) a π ( a | s ) s T ( s , a , s ) R ( s , a , s ) = Φ ( I γ P π ) D μ r π ,

2.2.4. GTD

The update rule of the GTD [4] algorithm is as follows:
ω t + 1 = ω t + β t ( δ t ϕ t ω t ) , θ t + 1 = θ t + α t ( ϕ t γ ϕ t ) ϕ t ω t ,
where the TD error δ t = r t + ( γ ϕ t ϕ t ) θ t .
Let g t = ( ω t / η , θ t ) ; thus, we can obtain
g t + 1 = g t + α t η b G T D , t + 1 A G T D , t + 1 g t ,
where b G T D , t + 1 = r t ϕ t , 0 and
A G T D , t + 1 = η I ϕ t ϕ t γ ϕ t γ ϕ t ϕ t ϕ t 0 .
Its key matrix is
A GTD = lim t E [ A GTD , t ] = η I A off A off 0 ,
b GTD = lim t E [ b GTD , t ] = Φ D μ r π 0 ,

2.2.5. GTD2

The update rule of the GTD2 [5] algorithm is as follows:
ω t + 1 = ω t + β t ( δ t ϕ t ω t ) ϕ t , θ t + 1 = θ t + α t ( ϕ t γ ϕ t ) ϕ t ω t ,
where the TD error δ t = r t + ( γ ϕ t ϕ t ) θ t .
Let g t = ( ω t / η , θ t ) ; thus, we can obtain
g t + 1 = g t + α t η b G T D 2 , t + 1 A G T D 2 , t + 1 g t ,
where b G T D 2 , t + 1 = r t ϕ t , 0 and
A G T D 2 , t + 1 = η ϕ t ϕ t ϕ t ϕ t γ ϕ t γ ϕ t ϕ t ϕ t 0 .
Its key matrix is
A GTD 2 = lim t E [ A GTD 2 , t ] = η C A off A off 0 ,
b GTD 2 = lim t E [ b GTD 2 , t ] = Φ D μ r π 0 ,
where C = E [ ϕ ϕ ] .

2.2.6. TDC

The update rule of the TDC [5] algorithm is as follows:
ω t + 1 = ω t + β t ( δ t ϕ t ω t ) ϕ t , θ t + 1 = θ t + α t δ t ϕ t α t γ ϕ t ( ϕ t ω t ) ,
where the TD error δ t = r t + ( γ ϕ t ϕ t ) θ t .
Its key matrix is
A TDC = A off C 1 A off ,
b TDC = A off C 1 Φ D μ r π ,

2.2.7. ETD

The update rule of the ETD [2] algorithm is as follows:
θ t + 1 θ t + α t F t ρ t r t + 1 + γ θ t ϕ t + 1 θ t ϕ t ϕ t = θ t + α t ( F t ρ t r t + 1 ϕ t F t ρ t ϕ t ϕ t γ ϕ t + 1 θ t ) = θ t + α t b ETD , t A ETD , t θ t ,
where F 0 = 1 and F t γ ρ t 1 F t 1 + 1 , t > 0 .
The key matrix of ETD is
A ETD = lim t E A ETD , t = lim t E μ F t ρ t ϕ t ϕ t γ ϕ t + 1 = s d μ ( s ) lim t E μ F t ρ t ϕ t ϕ t γ ϕ t + 1 S t = s = s d μ ( s ) lim t E μ F t S t = s f ( s ) E μ ρ t ϕ t ϕ t γ ϕ t + 1 S t = s = Φ D f ( I γ P π ) Φ ,
b ETD = lim t E [ b ETD , t ] = lim t E μ F t ρ t r t + 1 ϕ t = Φ D f r π ,
where D f is a diagonal matrix with a diagonal element approximated to f = ( I γ P π ) 1 d μ .

2.2.8. MRetrace

MRetrace [6] is a modified version of Retrace [16] with a convergence guarantee. Its update rule is as follows:
θ t + 1 = ˙ θ t + α t ρ t r t + 1 + x t γ θ t ϕ t + 1 θ t ϕ t ϕ t = θ t + α t ρ t r t + 1 ϕ t ρ t ϕ t ( ϕ t x t γ ϕ t + 1 ) θ t = θ t + α t b MR , t A MR , t θ t ,
where
x t = ˙ 1 max a ρ t = min a 1 ρ t = min a μ ( a | s t ) π ( a | s t ) ,
b MR , t = ρ t r t + 1 ϕ t , A MR , t = ρ t ϕ t ϕ t x t γ ϕ t + 1 .
b MR = lim t E [ b t ] = lim t E μ ρ t r t + 1 ϕ t = s d μ ( s ) E μ ρ t r t + 1 ϕ t | S t = s = s d μ ( s ) a μ ( a | s ) π ( a | s ) μ ( a | s ) r t + 1 ϕ ( s ) = s d μ ( s ) ϕ ( s ) a π ( a | s ) s T ( s , a , s ) R ( s , a , s ) = Φ D μ r π ,
The key matrix of MRetrace is
A MR = lim t E A t = lim t E μ ϕ t ( ϕ t x t γ E π [ ϕ t + 1 ] ) = s d μ ( s ) E μ ϕ ( s ) ( ϕ ( s ) x t γ E π [ ϕ ( s ) ] ) = s d μ ( s ) ϕ ( s ) ϕ ( s ) E μ [ x t γ E π [ ϕ ( s ) ] ] = s d μ ( s ) ϕ ( s ) ϕ ( s ) γ a μ ( a | s ) min b μ ( b | s ) π ( b | s ) E π [ ϕ ( s ) ] = s d μ ( s ) ϕ ( s ) ϕ ( s ) γ min b μ ( b | s ) π ( b | s ) s [ P π ] s s ϕ ( s ) = Φ D μ ( I γ D x P π ) Φ ,
where D x is the n × n diagonal matrix with d x on its diagonal, and each component of d x is d x ( s ) = min b μ ( b | s ) π ( b | s ) .

3. Finite Sample Analysis

The measurement criteria of finite sample analysis and convergence rate analysis are equivalent. They are both concerned with the relationship between errors and the number of iteration rounds.

3.1. Convergence Rate of General Temporal Difference Learning Algorithm

Let us start with a finite sample analysis of a general temporal difference learning algorithm. For the i.i.d. sequence { r t , ϕ t , ϕ t } , where r t and ϕ t are sampled from the Markov process with behavior policy μ , ϕ t is sampled from target policy π . Suppose its update rule of parameter θ is defined as follows:
θ t + 1 = θ t + α t b t A t θ t = θ t + α t ( h ( θ t ) + M t + 1 ) ,
where
M t + 1 = ( A A t ) θ t + b t b ,
h ( θ t ) = b A θ t = A θ A θ t = A ( θ t θ ) ,
where A = lim t E A t , b = lim t E [ b t ] , and the fixed point is θ = A 1 b . A and b are based on the i.i.d. sequence { r t , ϕ t , ϕ t } .
Assumption 1.
The key matrix A of the general temporal difference learning algorithm is positive definite.
Assumption 2.
The sequences { r t , ϕ t , ϕ t } have uniformly bounded second moments. Let F t = σ ( θ 1 , M 1 , , θ t 1 , M t ) ; then, fix some constant C s > 0 , such that the following holds:
E [ | | M t + 1 | | 2 | F t ] C s ( 1 + | | θ t θ | | 2 ) .
This assumption holds for any initial parameter vector θ 1 .
Assumption 3.
Step-size sequence α t satisfies α t ( 0 , 1 ) , t = 0 α t = , and t = 0 α t 2 < .
Let λ min ( X ) and λ max ( X ) denote the minimum and maximum eigenvalues of the matrix X .
Theorem 1.
(Convergence Rate in Expectation for General Temporal Difference Learning Algorithm). Assume that Assumptions 1–3 hold. For t 0 , we have
E θ t + 1 θ 2 e λ 0 t E θ 0 θ 2 + C s i = 0 t e λ i + 1 t α i 2 ,
where
λ i t = λ min ( A + A ) k = i t α k + λ max ( A A + C s I ) k = i t α k 2 , i t , 0 , i > t .
Proof. 
Note that the proof process is similar to the proof of Theorem 3.1 of [7].
Based on Definitions (33) and (35), we have
θ t + 1 θ = θ t + α t ( h ( θ t ) + M t + 1 ) θ = θ t θ + α t ( A ( θ t θ ) + M t + 1 ) = ( I α t A ) ( θ t θ ) + α t M t + 1 .
θ t θ 2 = ( θ t + 1 θ ) ( θ t + 1 θ ) = [ ( I α t A ) ( θ t θ ) + α t M t + 1 ] [ ( I α t A ) ( θ t θ ) + α t M t + 1 ] = ( θ t θ ) ( I α t A ) ( I α t A ) ( θ t θ ) + α t ( θ t θ ) ( I α t A ) M t + 1 + α t M t + 1 ( I α t A ) ( θ t θ ) + α t 2 M t + 1 2 .
Taking conditional expectations on both sides, and using E [ M t + 1 | F t ] = 0 , we get
E [ θ t + 1 θ 2 | F t ] = α t 2 E [ M t + 1 2 | F t ] + ( θ t θ ) ( I α t A ) ( I α t A ) ( θ t θ ) .
Therefore, using Assumption 2,
E [ θ t + 1 θ 2 | F t ] ( θ t θ ) Λ t ( θ t θ ) + C s α t 2 ,
where
Λ t = ( I α t A ) ( I α t A ) + C s α t 2 I .
Since Λ t is a symmetric matrix and the sum of two positive definite matrices, all its eigenvalues are real and positive. Let λ t : = λ max ( Λ t ) ; thus, we have λ t > 0 and
E [ θ t + 1 θ 2 | F t ] λ t θ t θ 2 + C s α t 2 .
Taking the expectations on both sides, we have
E θ t + 1 θ 2 λ t E θ t θ 2 + C s α t 2 .
Sequentially using the above inequality, we have
E θ t + 1 θ 2 k = 0 t λ k E θ 0 θ 2 + C s i = 0 t k = i + 1 t λ k α t 2 .
where we let k = t + 1 t λ k = 1 .
Based on Assumption 1, A is positive definite, and the matrices ( A + A ) and ( A A + C s I ) in (38) are positive definite. Thus, their minimum and maximum eigenvalues are strictly positive. Hence, using Weyl’s inequality, we have
λ t = λ max ( ( I α t A ) ( I α t A ) + C s α t 2 I ) λ max ( I α t ( A + A ) ) + α t 2 λ max ( A A + C s I ) 1 α t λ min ( A + A ) + α t 2 λ max ( A A + C s I ) e α t λ min ( A + A ) + α t 2 λ max ( A A + C s I )
In the case of λ t > 0 , t > 0 , when 0 < i < t , for the concatenated multiplication of (47) from i to t, we have
k = i t λ k k = i t e α k λ min ( A + A ) + α k 2 λ max ( A A + C s I ) = e k = i t α k λ min ( A + A ) + α k 2 λ max ( A A + C s I ) = e λ i t
The claim now follows. □

3.2. Convergence Rate of the MRetrace Algorithm

Assumption 4.
The Markov Chain ( s t ) is aperiodic and irreducible; thus, lim t P ( s t = s | s 0 = s ) = d μ ( s ) exists and is unique.
This assumption implies that the state distribution vector d μ of the behavior policy μ is the fixed point of
d μ = P μ d μ ,
where the element of matrix P μ is as follows:
[ P μ ] s s = μ ( a | s ) T ( s , a , s ) .
Assumption 5.
{ ϕ t , r t , E π [ ϕ t + 1 ] } is such that E μ [ | | ϕ t | | 2 | s t 1 ] , E μ [ r t 2 | s t 1 ] , E π [ | | ϕ t + 1 | | 2 | s t 1 ] are uniformly bounded.
Assumption 6.
The feature matrix Φ is column full rank.
Corollary 1.
(Convergence Rate in Expectation for MRetrace algorithm). Assume Assumptions 4–6 hold. Fix some constant C s > 0 , for t 0 , we have
E θ t + 1 θ 2 e λ 0 t E θ 0 θ 2 + C s i = 0 t e λ i + 1 t α i 2 .
where
λ i t = λ min ( A MR + A MR ) k = i t α k + λ max ( A MR A MR + C s I ) k = i t α k 2 , i t , 0 , i > t .
Proof. 
All we need is to show that the MRetrace algorithm satisfies the assumptions of Theorem 1.
According to the proof of Theorem 1 of [6], given Assumptions 4 and 6, the matrix A MR is positive definite. Under Assumption 5, there exists some constant C s > 0 , E [ | | M t + 1 | | 2 | F t ] C s ( 1 + | | θ t θ | | 2 ) . Then, based on Assumption 3, the claim follows by directly applying Theorem 1. □

4. How to Compare?

Theorem 1 and Corollary 1 are essentially simplified versions of Theorem 3.1 of [7], but their advantage lies in facilitating the analysis of the main factor affecting convergence rates.
To ensure a fair comparison among different learning algorithms, we need the same setting for each algorithm.
Assumption 7.
Assume each algorithm shares the same feature matrix, the same behavior policy, the same target policy, the same initial parameters θ 0 , the same constant C s , and the same learning rate sequences α t .
Corollary 2.
(The main factor affecting convergence rates). Assume Assumptions 1–3, 6 and 7. From the perspective of the expected convergence rate, the main factor that affects the convergence rate is the minimum eigenvalue 1 2 λ min ( A + A ) of the key matrix A . Furthermore, the larger the minimum eigenvalue of the key matrix, the faster the algorithm has a convergence rate. (This corollary is not actually what we discovered first. An anonymous expert reviewer of UAI2023 pointed out the role of the smallest eigenvalue. However, we did not find any relevant evidence or conclusions in the existing literature, so we formally stated this conclusion here).
Proof. 
Based on Assumptions 1 and 2, we obtain Theorem 1 on the expected convergence rate. Checking the error bound (37) in Theorem 1, removing the identical settings for different algorithms, one can easily find that each term contains only a key term e λ i t , where i [ 0 , t ] . When i < t ,
λ i t = λ min ( A + A ) k = i t α k + λ max ( A A + C s I ) k = i t α k 2 .
Based on Assumption 3, we have k = i t α t > k = i t α t 2 . Furthermore, fix variable i; thus, we have
lim t k = i t α t = ,
and
lim t k = i t α t 2 < .
That is
lim t k = i t α k lim t k = i t α k 2 .
Therefore, the main factor in (53) is λ min ( A + A ) k = i t α k . Finally, based on the same learning rate sequence, 1 2 λ min ( A + A ) is the main factor that affects the convergence rate.
In (37), for a given t, a smaller bound indicates a faster convergence rate. In (37), all elements including all e λ i t , E θ 0 θ 2 , C s , and all α i , are greater than zero, meaning that a smaller e λ i t leads to a faster convergence rate. Therefore, the smaller the value of λ i t in (53), the faster the convergence rate. Hence, the larger the value of 1 2 λ min ( A + A ) , the faster the convergence rate. □

5. Numerical Analysis

To compare the expected convergence rates of various algorithms, what we are going to do next is to compute and compare the minimum eigenvalues of each algorithm in different environments and different policies based on Corollary 2. The environments include two-state counterexample [2], Baird’s counterexample [3,5], Random Walk with tabular feature [5], Random Walk with inverted feature [5], Random Walk with dependent feature [5], and Boyan Chain [5,17]. Furthermore, in Random Walk, the target policy takes the right action in 60% of the time and the behavior policy selects the right and left action with equal probability [18]. In the Boyan Chain, the target policy and the behavior policy are the same.

5.1. Example Settings

Two-state counterexample: The θ 2 θ problem has only two states. From each state, there are two actions, left and right, which take the agent to the left or right state. All rewards are zeros. The features Φ = ( 1 , 2 ) are assigned to the left and the right state. The schematic of the environment is shown in Figure 1.
The behavior policy takes the equal probability to left or right in both states, i.e., P μ = 0.5 0.5 0.5 0.5 .
The target policy only selects action right in both states, i.e., P π = 0 1 0 1 .
The state distribution d μ = ( 0.5 , 0.5 ) , d x = d c = ( 0.5 , 0.5 ) , C = 2.5 , f = ( 0.5 , 9.5 ) , r π = 0 , r c = 0 .
Baird’s counterexample: Baird’s counterexample has seven states, and the schematic of the environment is shown in Figure 2.
The feature matrix is of dimensions ( 7 × 8 ) where each state is represented by an 8-dimensional feature, i.e.,
Φ = 2 0 0 0 0 0 0 1 0 2 0 0 0 0 0 1 0 0 2 0 0 0 0 1 0 0 0 2 0 0 0 1 0 0 0 0 2 0 0 1 0 0 0 0 0 2 0 1 0 0 0 0 0 0 1 2 .
The behavior policy takes equal probabilities to each state, i.e.,
P μ = 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 1 7 .
The target policy only selects the action to state 7 in both states, i.e.,
P π = 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 .
The state distribution
d μ = ( 1 7 , 1 7 , 1 7 , 1 7 , 1 7 , 1 7 , 1 7 ) ,
d x = d c = ( 1 7 , 1 7 , 1 7 , 1 7 , 1 7 , 1 7 , 1 7 ) ,
C = 0.571 0 0 0 0 0 0.286 0 0.571 0 0 0 0 0.286 0 0 0.571 0 0 0 0.286 0 0 0 0.571 0 0 0.286 0 0 0 0 0.571 0 0.286 0 0 0 0 0 0.571 0.286 0.286 0.286 0.286 0.286 0.286 0.286 1.429 .
f = ( 1 7 , 1 7 , 1 7 , 1 7 , 1 7 , 1 7 , 64 7 ) , r π = ( 0 , 0 , 0 , 0 , 0 , 0 , 0 ) , r c = ( 0 , 0 , 0 , 0 , 0 , 0 , 0 ) .
Random Walk: Random Walk is centered around a typical Markov Chain. This chain comprises five consecutive states, with two terminal states positioned at each extremity serving as absorptive endpoints.
The schematic of the environment is shown in Figure 3.
Specifically, its state–state transfer probability of behavior policy is
P μ = 0 0.6 0.4 0 0 0.4 0 0.6 0 0 0 0.4 0 0.6 0 0 0 0.4 0 0.6 0 0 0.6 0.4 0 .
The state–state transfer probability of the target policy is
P π = 0 0.5 0.5 0 0 0.5 0 0.5 0 0 0 0.5 0 0.5 0 0 0 0.5 0 0.5 0 0 0.5 0.5 0 .
The state distribution d μ = ( 1 9 , 2 9 , 3 9 , 2 9 , 1 9 ) , d c = ( 0.9 , 0.9 , 0.9 , 0.9 , 0.9 ) , d c = ( 5 6 , 5 6 , 5 6 , 5 6 , 5 6 ) , f = ( 0.773 , 1.84 , 3.333 , 2.56 , 1.493 ) , r π = ( 0.4 , 0, 0, 0, 0.6 ) , r c = ( 0.4 , 0, 0, 0, 0.5 ) .
The Random Walk environment has three feature representations, which are called tabular features, inverted features, and dependent features. The feature matrix of Random Walk with tabular features is
Φ = 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 .
C = 0.111 0 0 0 0 0 0.222 0 0 0 0 0 0.333 0 0 0 0 0 0.222 0 0 0 0 0 0.111 .
The feature matrix of Random Walk with inverted features is
Φ = 0 0.5 0.5 0.5 0.5 0.5 0 0.5 0.5 0.5 0.5 0.5 0 0.5 0.5 0.5 0.5 0.5 0 0.5 0.5 0.5 0.5 0.5 0 .
C = 0.222 0.167 0.139 0.167 0.194 0.167 0.194 0.111 0.139 0.167 0.139 0.111 0.167 0.111 0.139 0.167 0.139 0.111 0.194 0.167 0.194 0.167 0.139 0.167 0.222 .
The feature matrix of Random Walk with dependent features is
Φ = 1 0 0 1 2 1 2 0 1 3 1 3 1 3 0 1 2 1 2 0 0 1 .
C = 0.333 0.222 0.111 0.222 0.333 0.222 0.111 0.222 0.333 .
Boyan Chain: The Boyan Chain consists of 13 states, each of which is represented by 4 state features. The feature matrix of the Boyan Chain with dependent features is
Φ = 1 0 0 0 0.75 0.25 0 0 0.5 0.5 0 0 0.25 0.75 0 0 0 1 0 0 0 0.75 0.25 0 0 0.5 0.5 0 0 0.25 0.75 0 0 0 1 0 0 0 0.75 0.25 0 0 0.5 0.5 0 0 0.25 0.75 0 0 0 1 .
The state distribution d μ = ( 0.108 , 0.054 , 0.081 , 0.068 , 0.075 , 0.071 , 0.073 , 0.072 , 0.072 , 0.072 , 0.072 , 0.072 , 0.108 ) ,   d x = d c = ( 1 , 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ) ,
C = 0.163 0.043 0 0 0.043 0.199 0.045 0 0 0.045 0.199 0.045 0 0 0.045 0.172 .
f = ( 1.084 , 0.542 , 0.813 , 0.678 , 0.745 , 0.712 , 0.729 , 0.72 , 0.724 , 0.722 , 0.723 , 0.723 , 1.084 ) , r π = r c = ( 3 , 3 , 3 , 3 , 3 , 3 , 3 , 3 , 3 , 3 , 3 , 2 , 0 ) .
Then, the state–state transfer probability of behavior policy is the same as the state–state transfer probability of target policy, i.e., P μ = P π , where the element of matrix P μ is as follows, for i , j [ 0 , 12 ] :
P μ [ i , j ] = 0.5 if i 10 and j = i + 1 0.5 if i 10 and j = i + 2 1 if i = 11 and j = 12 1 if i = 12 and j = 0 0 otherwise .
The schematic of the environment is shown in Figure 4.

5.2. Results and Analysis

Based on Table 1, first, we need to set Φ , P μ , P π , D c , r c , r π , C, D f , and D x for each setting. Then, based on the property d μ = P μ d μ , we compute the eigenvector of the matrix P μ with eigenvalue 1.0, and we unitize it to obtain d μ and D μ . (It is important to note that when there are absorbing states in a Markov Chain, the probability distribution is 1.0 only at the absorbing states and 0 at all other states. Therefore, we adopt a restart approach, jumping directly back to the initial states, thus forming a probability transition matrix P μ without absorbing states.) After all, we compute the key matrix for each algorithm and its minimum eigenvalue. Note that the step-size ratio η of the auxiliary parameter to the learning parameter is usually set to η 1.0 .
The minimum eigenvalues in several examples for each algorithm are summarized in Table 2. We can find the following: (1) In Baird’s counterexample and a two-state counterexample, the minimum eigenvalues of key matrices in off-policy TD and Retrace are both less than 0, indicating that they will diverge in these two counterexamples, which is consistent with the existing research [2]. Additionally, compared with off-policy TD, Retrace does have some mitigation towards divergence but cannot avoid it.
(2) In Baird’s counterexample, the minimum eigenvalues of GTD2, TDC, ETD, and MRetrace are all less than zero, indicating that their key matrices are not positive definite. This seems inconsistent with our understanding. The main reason is that in Baird’s counterexample, the feature matrix is 7 × 8 , and is not column full rank, which is inconsistent with the assumption in their theorems. Note that the absolute value of the minimum eigenvalue is very small.
(3) Except for Baird’s counterexample, the minimum eigenvalues of GTD and GTD2 are all zeros. The reason is that matrices 1 2 λ min ( A + A ) of GTD and GTD2 are positive semi-definite. In the context of this paper, we are unable to distinguish which one is faster between GTD and GTD2 in numerical analysis.
(4) The minimum eigenvalue of TDC is higher than GTD and GTD2, which is consistent with the literature.
(5) Except for Baird’s counterexample, the minimum eigenvalue of ETD is the largest.
(6) Except for Baird’s counterexample, MRetrace has the second-largest minimum eigenvalues.
(7) All the minimum eigenvalues of BR are greater than 0, making it the only one to remain positive definite in all examples. However, except for Baird’s counterexample, its minimum eigenvalue is not large.
(8) The Boyan Chain is an on-policy setting; off-policy TD is implemented in on-policy; and off-policy TD, Retrace, and MRetrace have the same minimum eigenvalue of 0.024. BR and TDC have the same minimum eigenvalue of 0.002, indicating that BR and TDC are not suitable for on-policy learning.
(9) It is surprising that in an on-policy setting, the minimum eigenvalue of ETD is larger than that of on-policy TD. This implies that in terms of the expected convergence rate, ETD is the most recommended option for on-policy learning.
To the best of our knowledge, this is the first time that various temporal difference learning algorithms have been compared for their convergence rates in a very intuitive numerical analysis manner.
In summary, in the expected sense, ETD has the fastest convergence rate, followed by MRetrace.

6. Experimental Studies

In Section 3, we proposed Corollary 2, and in Section 4, we compared the sizes of the minimum eigenvalues of different algorithms for various environment settings. This means that we carried out theoretical analysis combined with numerical analysis, but whether the analytical results reflect the actual situation needs to be experimentally verified. Therefore, we adopted the same environment settings as in Section 4.
Each algorithm runs independently 20 times, with 1000 steps per run, and calculates the mean and standard deviation.
To compare convergence rates, we need to observe the trend of | θ t θ | over time step t. Note that according to Table 1, different algorithms have different optimal solutions θ = A 1 b , so we need to calculate their optimal solutions separately for each algorithm and then measure the errors.
The learning rate is set to satisfy Assumption 3, α t = α 0 × 1 t + 1 , where α 0 is an initial learning rate. We set η = 4 for GTD and GTD2 in all environments. In two-state counterexamples, α 0 = 0.1 , and γ = 0.9 . In Baird’s counterexamples, α 0 = 0.05 , and γ = 0.99 . In Random Walk, α 0 = 0.25 , and γ = 0.9 . In a Boyan Chain, α 0 = 0.25 , and γ = 0.9 .
The learning curves of different algorithms in different environments are shown in Figure 5, where each curve displays the mean and standard deviation of the errors. We can find the following: (1) In Random Walk with dependent features, the convergence rate analysis is consistent with the learning curves of each algorithm. They have the same order: ETD > MRetrace > off-policy TD > Retrace > TDC ≥ BR > GTD2 ≥ GTD.
(2) Off-policy TD and Retrace diverge in both counterexamples, but Retrace diverges more slowly compared with off-policy TD. This is consistent with the numerical analysis in Section 4.
(3) In Baird’s counterexample, GTD descends faster than GTD2 and TDC. This may be related to the numerical analysis showing that the minimum eigenvalues of GTD2 and TDC are less than 0. Therefore, this is consistent with the analysis.
(4) In Baird’s counterexample, ETD diverges. On the one hand, this is related to high variances of ETD reported in the literature [6,19]; on the other hand, it is also related to the numerical analysis, showing that the minimum eigenvalue is less than 0.
(5) In a two-state counterexample, compared to BR, ETD, and MRetrace, the algorithms GTD, GTD2, and TDC converge very slowly. Additionally, BR converges slower than MRetrace and ETD. These observations are consistent with our numerical analysis. However, ETD is slower than MRetrace, which is attributed to the high variance of ETD.
(6) In Random Walk and the Boyan Chain, TDC converges much faster than GTD and GTD2, which is consistent with our numerical analysis. This observation also aligns with existing research.
(7) In Random Walk and the Boyan Chain, the convergence rate of ETD is remarkably fast, which aligns with our numerical analysis. ETD is reported to be suitable for off-policy learning, but its exceptional performance in on-policy learning is somewhat incredible.
(8) In the Boyan Chain, off-policy TD is implemented as on-policy TD. The learning curves of TD, Retrace, and MRetrace overlap. This is consistent with our numerical analysis.
In conclusion, the convergence rates of the algorithms in the experiments align with the numerical analysis. Moreover, any inconsistencies have interpretable underlying reasons.

7. Conclusions and Future Work

Based on the proposed convergence rate for constructing general off-policy temporal difference learning algorithms, this paper proved that the primary determinant influencing convergence rate is the minimum eigenvalue of the key matrix. Focusing on this factor will be more conducive to the development of faster converging off-policy learning algorithms.
The limitations of this paper include the following aspects:
(1)
This paper assumes that the learning rates of all algorithms are the same; however, in reality, different algorithms have different ranges of applicable learning rates.
(2)
This paper does not consider the scenario of a fixed learning rate.
(3)
This paper focuses on learning prediction and does not address learning control.
Future works need to address the above limitations and explore how to design faster algorithms based on the conclusions of this paper.
In the end, we discovered a contradiction. Sutton et al. [4] proved that A GTD = η I A off A off 0 is positive definite. Note that in the paper, G = η I A off A off 0 is proved to be negative definite [4]. According to Theorem A.3 of [20], the positive definiteness of square matrix A is equivalent to the positive definiteness of ( A + A ) ; thus, ( A GTD + A GTD ) is positive definite. However, our calculations in this paper showed that ( A GTD + A GTD ) = 2 η I 0 0 0 is positive semi-definite, not positive definite. Therefore, the conclusion that A GTD is positive definite is questionable.

Author Contributions

Conceptualization, X.C.; methodology, X.C.; software, W.Q.; formal analysis, W.Q.; investigation, Y.G.; discussion, S.Y.; writing—review and editing, X.C.; supervision, W.W. All authors have read and agreed to the published version of the manuscript.

Funding

This study was supported by the National Natural Science Foundation, China (Nos. 62276142, 62206133, and 62202240).

Institutional Review Board Statement

Not applicable.

Informed Consent Statement

Not applicable.

Data Availability Statement

Data are contained within the article.

Conflicts of Interest

The authors declare no conflicts of interest. The funders had no role in the design of this study; in the collection, analyses, or interpretation of data; in the writing of this manuscript; or in the decision to publish the results.

References

  1. Sutton, R.S.; Barto, A.G. Reinforcement Learning: An Introduction, 2nd ed.; The MIT Press: Cambridge, MA, USA, 2018. [Google Scholar]
  2. Sutton, R.S.; Mahmood, A.R.; White, M. An emphatic approach to the problem of off-policy temporal-difference learning. J. Mach. Learn. Res. 2016, 17, 2603–2631. [Google Scholar]
  3. Baird, L. Residual algorithms: Reinforcement learning with function approximation. In Proceedings of the 12th International Conference on Machine Learning, Tahoe City, CA, USA, 9–12 July 1995; pp. 30–37. [Google Scholar]
  4. Sutton, R.S.; Maei, H.R.; Szepesvári, C. A Convergent O(n) Temporal-difference Algorithm for Off-policy Learning with Linear Function Approximation. Adv. Neural Inf. Process. Syst. 2008, 21, 1609–1616. [Google Scholar]
  5. Sutton, R.; Maei, H.; Precup, D.; Bhatnagar, S.; Silver, D.; Szepesvári, C.; Wiewiora, E. Fast gradient-descent methods for temporal-difference learning with linear function approximation. In Proceedings of the 26th International Conference on Machine Learning, Montreal, QC, Canada, 14–18 June 2009; pp. 993–1000. [Google Scholar]
  6. Chen, X.; Ma, X.; Li, Y.; Yang, G.; Yang, S.; Gao, Y. Modified retrace for off-policy temporal difference learning. In Proceedings of the Thirty-Ninth Conference on Uncertainty in Artificial Intelligence, Pittsburgh, PA, USA, 31 July–4 August 2023; pp. 303–312. [Google Scholar]
  7. Dalal, G.; Szörényi, B.; Thoppe, G.; Mannor, S. Finite sample analyses for TD (0) with function approximation. In Proceedings of the AAAI Conference on Artificial Intelligence, New Orleans, LO, USA, 2–7 February 2018; Volume 32. [Google Scholar]
  8. Dalal, G.; Thoppe, G.; Szörényi, B.; Mannor, S. Finite sample analysis of two-timescale stochastic approximation with applications to reinforcement learning. In Proceedings of the Conference On Learning Theory, PMLR, Stockholm, Sweden, on 5–9 July 2018; pp. 1199–1233. [Google Scholar]
  9. Gupta, H.; Srikant, R.; Ying, L. Finite-time performance bounds and adaptive learning rate selection for two time-scale reinforcement learning. In Proceedings of the 33rd International Conference on Neural Information Processing Systems, Vancouver, BC, Canada, 8–14 December 2019; pp. 4704–4713. [Google Scholar]
  10. Xu, T.; Zou, S.; Liang, Y. Two time-scale off-policy TD learning: Non-asymptotic analysis over Markovian samples. In Proceedings of the 33rd International Conference on Neural Information Processing Systems, Vancouver, BC, Canada, 8–14 December 2019; pp. 10634–10644. [Google Scholar]
  11. Dalal, G.; Szorenyi, B.; Thoppe, G. A tale of two-timescale reinforcement learning with the tightest finite-time bound. In Proceedings of the AAAI Conference on Artificial Intelligence, New York, NY, USA, 7–8 February 2020; Volume 34, pp. 3701–3708. [Google Scholar]
  12. Durmus, A.; Moulines, E.; Naumov, A.; Samsonov, S.; Scaman, K.; Wai, H.T. Tight high probability bounds for linear stochastic approximation with fixed stepsize. Adv. Neural Inf. Process. Syst. 2021, 34, 30063–30074. [Google Scholar]
  13. Xu, T.; Liang, Y. Sample complexity bounds for two timescale value-based reinforcement learning algorithms. In Proceedings of the International Conference on Artificial Intelligence and Statistics, PMLR, Virtual, 13–15 April 2021; pp. 811–819. [Google Scholar]
  14. Zhang, S.; Des Combes, R.T.; Laroche, R. On the convergence of SARSA with linear function approximation. In Proceedings of the International Conference on Machine Learning, PMLR, Honolulu, HI, USA, 23–29 July 2023; pp. 41613–41646. [Google Scholar]
  15. Wang, S.; Si, N.; Blanchet, J.; Zhou, Z. A finite sample complexity bound for distributionally robust q-learning. In Proceedings of the International Conference on Artificial Intelligence and Statistics, PMLR, Honolulu, HI, USA, 23–29 July 2023; pp. 3370–3398. [Google Scholar]
  16. Munos, R.; Stepleton, T.; Harutyunyan, A.; Bellemare, M. Safe and efficient off-policy reinforcement learning. Adv. Neural Inf. Process. Syst. 2016, 29, 1054–1062. [Google Scholar]
  17. Boyan, J.A. Technical update: Least-squares temporal difference learning. Mach. Learn. 2002, 49, 233–246. [Google Scholar] [CrossRef]
  18. Ghiassian, S.; Patterson, A.; Garg, S.; Gupta, D.; White, A.; White, M. Gradient temporal-difference learning with regularized corrections. In Proceedings of the International Conference on Machine Learning, PMLR, Virtual, 13–18 July 2020; pp. 3524–3534. [Google Scholar]
  19. Zhang, S.; Whiteson, S. Truncated emphatic temporal difference methods for prediction and control. J. Mach. Learn. Res. 2022, 23, 6859–6917. [Google Scholar]
  20. Sutton, R.S. Learning to predict by the methods of temporal differences. Mach. Learn. 1988, 3, 9–44. [Google Scholar] [CrossRef]
Figure 1. Two-state counterexample, where the blue solid arrows represent the behavior policy μ , and the red dashed arrows represent the target policy π .
Figure 1. Two-state counterexample, where the blue solid arrows represent the behavior policy μ , and the red dashed arrows represent the target policy π .
Mathematics 12 02930 g001
Figure 2. Baird’s counterexample, where the probability of the solid action and the dashed action in behavior policy μ and target policy π are μ ( d a s h e d · ) = 6 7 , μ ( s o l i d · ) = 1 7 and π ( s o l i d · ) = 1 .
Figure 2. Baird’s counterexample, where the probability of the solid action and the dashed action in behavior policy μ and target policy π are μ ( d a s h e d · ) = 6 7 , μ ( s o l i d · ) = 1 7 and π ( s o l i d · ) = 1 .
Mathematics 12 02930 g002
Figure 3. Random Walk. All walks begin in state 3. Under the behavior policy, take either a left or right action with a probability of 0.5 in each state. Under the target policy, take either a left or right action with a probability of 0.4 or 0.6 in each state.
Figure 3. Random Walk. All walks begin in state 3. Under the behavior policy, take either a left or right action with a probability of 0.5 in each state. Under the target policy, take either a left or right action with a probability of 0.4 or 0.6 in each state.
Mathematics 12 02930 g003
Figure 4. Boyan Chain. In state 0–10, each solid action is taken with probability 0.5. In states 11 and 12, the probability of a solid action is 1.
Figure 4. Boyan Chain. In state 0–10, each solid action is taken with probability 0.5. In states 11 and 12, the probability of a solid action is 1.
Mathematics 12 02930 g004
Figure 5. Comparisons of learning curves in different environments. (a) Two-state counterexamples; (b) Baird’s counterexamples; (c) Random Walk with tabular features; (d) Random Walk with inverted features; (e) Random Walk with dependent features; (f) Boyan Chain.
Figure 5. Comparisons of learning curves in different environments. (a) Two-state counterexamples; (b) Baird’s counterexamples; (c) Random Walk with tabular features; (d) Random Walk with inverted features; (e) Random Walk with dependent features; (f) Boyan Chain.
Mathematics 12 02930 g005
Table 1. The general solution expressions for each algorithm ( θ = A 1 b ).
Table 1. The general solution expressions for each algorithm ( θ = A 1 b ).
AlgorithmKey Matrix APositive Definiteb
Off-policy TD A off = Φ D μ ( I γ P π ) Φ × b off = Φ D μ r π
Retrace Φ D μ D c ( I γ P π ) Φ × Φ D μ r c
BR Φ ( I γ P π ) D μ ( I γ P π ) Φ Φ ( I γ P π ) D μ r π
GTD η I A off A off 0 b off 0
GTD2 η C A off A off 0 b off 0
TDC A off C 1 A off A off C 1 b off
ETD Φ D f ( I γ P π ) Φ Φ D f r π
MRetrace Φ D μ ( I γ D x P π ) Φ b off
Table 2. Minimum eigenvalues 1 2 λ min ( A + A ) of various algorithms on several examples.
Table 2. Minimum eigenvalues 1 2 λ min ( A + A ) of various algorithms on several examples.
AlgorithmTwo-StateBaird’sRandom WalkBoyan Chain
TabularInvertedDependent
Off-policy TD 0.2 0.791 0.018 0.017 0.07 0.024
Retrace 0.1 0.113 0.017 0.015 0.063 0.024
BR 0.34 9.673 × 10−17 0.002 0.007 0.033 0.002
GTD000000
GTD20−1.077 × 10−170000
TDC 0.016 0.002 0.002 0.007 0.011 0.002
ETD 3 . 4 −2.82 × 10−16 0 . 195 0 . 165 0 . 76 0 . 245
MRetrace 1.15 −2.141 × 10−17 0.046 0.02 0.094 0.024
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Share and Cite

MDPI and ACS Style

Chen, X.; Qin, W.; Gong, Y.; Yang, S.; Wang, W. On Convergence Rate of MRetrace. Mathematics 2024, 12, 2930. https://doi.org/10.3390/math12182930

AMA Style

Chen X, Qin W, Gong Y, Yang S, Wang W. On Convergence Rate of MRetrace. Mathematics. 2024; 12(18):2930. https://doi.org/10.3390/math12182930

Chicago/Turabian Style

Chen, Xingguo, Wangrong Qin, Yu Gong, Shangdong Yang, and Wenhao Wang. 2024. "On Convergence Rate of MRetrace" Mathematics 12, no. 18: 2930. https://doi.org/10.3390/math12182930

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop