Parallel Bootstrap-Based On-Policy Deep Reinforcement Learning for Continuous Fluid Flow Control Applications

Abstract

The coupling of deep reinforcement learning to numerical flow control problems has recently received considerable attention, leading to groundbreaking results and opening new perspectives for the domain. Due to the usually high computational cost of fluid dynamics solvers, the use of parallel environments during the learning process represents an essential ingredient to attain efficient control in a reasonable time. Yet, most of the deep reinforcement learning literature for flow control relies on on-policy algorithms, for which the massively parallel transition collection may break theoretical assumptions and lead to suboptimal control models. To overcome this issue, we propose a parallelism pattern relying on partial-trajectory buffers terminated by a return bootstrapping step, allowing a flexible use of parallel environments while preserving the on-policiness of the updates. This approach is illustrated on a CPU-intensive continuous flow control problem from the literature.

1. Introduction

Deep neural networks (DNNs) have become a pervasive approach in a large variety of scientific domains in the course of the last decade, achieving multiple breakthroughs in domains such as image classification tasks [1,2], speech recognition [3] or generative tasks [4,5]. Thanks to cheaper hardware and generalized access to large computational resources, such advances have led to a general evolution of the reference methods at both academic and industrial levels.

Among these developments, decision-making techniques have largely benefited form the coupling of DNNs with reinforcement learning algorithms (called deep reinforcement learning, or DRL), due to their feature extraction capabilities and their ability to handle high-dimensional state spaces. Unprecedented efficiency has been achieved in many domains such as robotics [6], language processing [7], or games [8,9], but also in the context of industrial applications [10,11,12].

In recent years, DRL-based approaches have made their way into the domain of flow control, with an increasing amount of contributions on varied topics such as (but not limited to) drag reduction [13], collective swimming [14] or heat transfers [15]. Although a handful of couplings of DRL with experimental setups were reported, most contributions make use of numerical environments relying on computational fluid dynamics (CFD) solvers [16,17], making the performance of the latter an important lever for the successful learning of a control strategy by a DRL agent. Yet, in order to control processes of increasing computational loads, the use of parallel environments to accelerate the sample collection between agent updates also appears as a key ingredient, allowing to further exploit existing resources and reducing the time-to-control (here defined as the computational time required to reach efficient control). In 2019, such setup was introduced by Rabault and Kuhnle in the context of flow control for the drag reduction on a cylinder at low Reynolds number [18]. In this contribution, the authors showed that, for a configuration where the CFD time represents almost 100% of the time-to-control, using a parallel collection of samples could yield an excellent speedup up to the point where the number of parallel environments (hereafter denoted as $n_{\mathrm{env}}$) becomes equal to the number of full episodes used for a single update (hereafter denoted as $n_{\mathrm{update}}$, in this case equal to 20 episodes). Pushing the parallelization process beyond this point resulted in “over-parallelization” (sic) and led to observable flat steps in the learning process (see [18], Figure 4).

Although efficient, the approach introduced above comprises two major drawbacks. First, the “over-parallelization process” inherently leads to off-policy updates of the agent (i.e., the agent is trained with samples produced by a previous policy), which introduces bias in the policy gradient estimates and increases the risk of the agent falling into local optima. While importance sampling corrections could be used to account for the discrepancy between the current policy and the behavior policy, such an approach is known to introduce large variance in the estimate and require additional tuning [19,20]. Second, in order to take maximum advantage of the parallel sample collection, this approach constrains the size of the buffer update to be (i) a multiple of the number of transitions within an episode, and (ii) a multiple of the number of parallel environments. These two points may lead either to a suboptimal control model or to a suboptimal use of the available computational resources. To overcome these issues, we propose an update approach based on partial trajectories terminated by a return bootstrapping step to mimic a continuing environment (i.e., the last reward of each parallel update buffer is modified to account for the continuous nature of the control task). The concept of partial trajectories is not new and was, for example, presented by Schulman in the original proximal policy optimization (PPO) paper (see [21], Section 5), while the bootstrapping method was originally proposed by Pardo et al. [22]. As will be shown below, the combination of these two approaches allows us to design a flexible parallel sample collection pattern, while retaining the on-policiness of the PPO algorithm (i.e., the agent is trained with samples produced by the current policy). This represents a major asset in the context of fluid flow control, where efficient parallel sample collection eventually allows the control of complex, CPU-intensive environments.

The present paper is organized as follows: in Section 2.1, a short reminder of the basics of on-policy DRL algorithms and proximal policy optimization is provided. Then, a recall is made on the bootstrapping technique in Section 2.3, after which the proposed bootstrapped partial trajectories approach is detailed in Section 2.4. To benchmark the proposed method, a continuous flow control case from the literature is presented in Section 3 (namely the control of a falling fluid film, adapted from [23]). This case is then exploited in Section 4 to benchmark (i) the interest of bootstrapping and (ii) the proposed parallel paradigm. Finally, conclusions and perspectives are given.

2. Parallel Bootstrap-Based on-Policy Deep Reinforcement Learning

2.1. On-Policy DRL Algorithms

Policy-based methods maximize the expected discounted cumulative reward of a policy $\pi \left(a\right|s)$ mapping states to actions, resorting to a probability distribution over actions given states. Among these techniques, two types of algorithms must be differentiated:

on-policy algorithms usually require that the samples they use for training are generated with the current policy. In other words, after having collected a batch of transitions using the current policy, these data are used to update the agent and cannot be re-used for future updates;

off-policy algorithms are able to train on samples that were not collected with their current policy. They usually use a replay buffer to store transitions, and randomly sample mini-batches from it to perform updates. Hence, samples collected with a given policy can be re-used multiple times during the training procedure.

Although off-policy algorithms naturally exhibit a better sample efficiency, their stability is not guaranteed, and, as of today, they have not yet made their way in the DRL-based flow control domain [17]. Contrarily, although less sample-efficient, on-policy algorithms present good stability properties, ease of implementation and tuning, and are widely represented in the field of DRL-based flow control. By focusing on on-policy algorithms, the present study can deliver more useful insights to the community. In the following section, we focus on the details of the well-known PPO algorithm [21].

2.2. Proximal Policy Optimization (PPO)

The PPO algorithm belongs to the class of actor-critic methods [24], in which an actor provides actions based on observations by sampling from a parameterized policy ${\pi }_{\theta }$, while a critic is devoted to evaluate the future expected discounted cumulative reward. The standard loss used to update the actor network reads:

$$L\left(\theta \right)=\underset{\tau \sim {\pi }_{\theta }}{\mathbb{E}}\left[\sum _{t=0}^{T}log\left({\pi }_{\theta }\left(a_t\right|s_t)\right)A^{{\pi }_{\theta }}(s_t,a_t)\right],$$

where $A^{{\pi }_{\theta }}(s,a)$ is the advantage function, that represents the improvement in the expected cumulative reward when taking action a in state s, compared to the average of all possible actions taken in state s. The advantage function is evaluated thanks to the rewards collected from the environment, and the evaluation of the value function is provided by the critic. Although displaying good performance, vanilla actor-critic techniques displayed a high sensitivity to the learning rate, with small learning rates implying slow learning, while large learning rates leading to possible performance collapses. To overcome these issues, the proximal policy optimization [21] uses a simple yet effective heuristic that helps avoid destructive updates. Namely, it relies on a clipped surrogate loss:

$$L\left(\theta \right)=\underset{(s,a)\sim {\pi }_{{\theta }_{\mathrm{old}}}}{\mathbb{E}}\left[min\left(\frac{{\pi }_{\theta }\left(a\right|s)}{{\pi }_{{\theta }_{old}}\left(a\right|s)},g\left(ϵ,A^{{\pi }_{{\theta }_{\mathrm{old}}}}(s,a)\right)\right)A^{{\pi }_{{\theta }_{\mathrm{old}}}}(s,a)\right],$$

where

$$g(ϵ,A)=\left\{\begin{array}{cc}(1+ϵ)A\hfill & \mathrm{if}A\ge 0,\hfill \\ (1-ϵ)A\hfill & \mathrm{if}A<0,\hfill \end{array}\right.$$

and $ϵ$ is the clipping range, a small user-defined parameter defining how far away the new policy is allowed to go from the old one. Due to its improved learning stability and its relatively robust behaviour with respect to hyper-parameters, the PPO algorithm has received considerable attention in the DRL community, including in the context of flow control [17].

It seems worth noting that, in practice, although PPO is considered an on-policy method in the sense that it does not make use of a replay buffer, it is not strictly on-policy, as the collected transitions will be used for multiple epochs in the course of a single update before being discarded. This fact leads a part of the community to label PPO as an off-policy method, which is fundamentally correct, although in essence the method is fundamentally different from state-of-the-art off-policy methods such as deep deterministic policy gradients-like methods (DDPG [25], TD3 [26]).

2.3. Bootstrapping

DRL methods can be used either to tackle episodic or continuous tasks. In episodic tasks, the agent has a limited amount of time to successfully reach a given goal, the provided time limit being an intrinsic characteristic of the problem (for example, the case of a robotic arm moving an object from an initial position to a final position). In continuous tasks, the time limit is often arbitrary, the control being supposed to run indefinitely (for example, the case of active drag reduction around an obstacle). In the case of continuous control, the time limit is set only so the environment can be regularly reset during the training, leading to an improved diversity of samples and a good representation of all the stages of control. In the context of on-policy algorithms such as PPO, this distinction leads to a subtle yet capital difference in the way the advantage buffer must be terminated when an episode is ended for a time-out reason [22]. Traditionally, once an episode is terminated, the advantage vector is assembled using the reward vector $\mathit{r}$ collected from the environment during the episode, the estimated value vector ${\hat{\mathit{v}}}_{{\mathit{\pi }}_{\mathit{\theta }}}$ that estimates the discounted cumulative reward starting from a given state until the end of the episode, and the termination mask $\mathit{m}$, whose values are equal to 1 for each non-terminal state, and 0 for terminal states (so on a single episode, the termination mask is typically a vector of 1 terminated with a 0). Then, the advantage vector can be assembled as shown in Algorithm 1.

Algorithm 1 Traditional advantage vector assembly
1:	given: the reward vector $\mathit{r}$
2:	given: the value vector ${\widehat{\mathit{v}}}_{{\mathit{\pi }}_{\mathit{\theta }}}$
3:	given: the termination mask $\mathit{m}$
4:	for  $t=0,n_{\mathrm{steps}}-1$do
5:	$y_t=r_t$ if $s_t$ is terminal else $y_t=r_t+\gamma {\widehat{v}}_{{\pi }_{\theta }}\left(s_{t+1}\right)$
6:	end for
7:	for  $t=n_{\mathrm{steps}}-2,0$  do
8:	$y_t=y_t+\gamma m_t{y}_{t+1}$
9:	end for
10:	$\mathit{A}=\mathit{y}-{\widehat{\mathit{v}}}_{{\mathit{\pi }}_{\mathit{\theta }}}$

The computed advantage vector is later used in the computation of the actor loss (here, the computation of the standard advantage function is presented for simplicity, yet the comments made in this section still hold for more complex advantage functions, such as the generalized advantage estimate [27], for example). Yet, the Algorithm 1 does not account for terminations due to time limits in the context of continuous tasks. Hence, when trained, providing such an advantage vector to the agent does not account for the possible future rewards that could have been experienced if a different arbitrary time limit had been used. Moreover, this approach inherently brings a credit attribution problem: reaching a similar state in the course of an episode or on a time-out termination would lead to very different outcomes that would be evaluated with the same inaccurate value function estimate ${\widehat{v}}_{{\pi }_{\theta }}\left(s_t\right)$, thus leading to a degraded learning process. However, a fairly simple remedy called bootstrapping consists in replacing the “if $s_t$ is terminal” condition of Algorithm 1 by “if $s_t$ is terminal and not a time-out”. Indeed, one can clearly see from Algorithm 1 at line 8 that modifying the final target value $y_t$ in the case of a time-out (i.e., $t=T$) will modify all the previous target values $y_{t<T}$, thus having a large impact on the actor update, and eventually leading to a significant performance improvement. Experiments using bootstrapping alone in the context of continuous flow control tasks are presented in Section 4.1. Additional results on regular benchmark control tasks from the gym and mujoco packages are also provided in Appendix A.

2.4. Parallel Bootstrap-Based Learning

In the context of CPU-expensive CFD environments, speeding up the training of DRL agents by harnessing the capabilities of parallelism can lead to substantial gains in computational resources. Although this can be accomplished by exploiting the inner parallelism of the CFD computation itself, collecting data from environments running in parallel is also a well-known technique that has largely spread in the community. In the context of the coupling of CFD environments with DRL, such improvement represents a key ingredient for the discovery of efficient control laws, as the environment can represent from 80% to more than 99% of the computational time. In [18], the authors consider a 2D drag reduction case using the PPO algorithm, setting the update frequency of their agent to $n_{\mathrm{update}}=20$ episodes. Using an asynchronous parallelism of the environments, the authors report an excellent speedup up to $n_{\mathrm{env}}=20$ parallel environments, and a decent performance improvement up to 60. Yet, for $n_{\mathrm{env}}>n_{\mathrm{update}}$, a fraction of the updates are naturally performed in an off-policy way, due to the fact that the samples used were produced using a different policy than the one being updated. Although an appreciable speedup is still observed, this choice can lead to a degraded learning, as will be evidenced in Section 4.2. Here, we propose to exploit the bootstrapping technique presented above to design a synchronous parallel paradigm that respects the on-policy nature of PPO.

The proposed method is illustrated in Figure 1 for a simple configuration: a regular episode consists of four transitions, and for this example it is decided that an update of the agent requires $n_{\mathrm{update}}=2$ full episodes, or eight transitions. For $n_{\mathrm{env}}=1$, two episodes are unrolled sequentially between each update. For $n_{\mathrm{env}}=2$, transition sampling is effectively sped up while retaining the same update pattern, as two full episodes can be collected between each agent learning step. However, when reaching $n_{\mathrm{env}}=4$, four full episodes are collected at once, and are then used to form two update buffers. While the first update will be on-policy, the second one will violate the on-policiness of the method, leading to possibly sub-optimal control. The proposed partial-trajectory approach holds two major differences: first, all collected transition buffers are terminated with a return bootstrap step; second, in the case of $n_{\mathrm{env}}=4$, only two transitions are unrolled for each environment, and a first buffer update is formed using four partial bootstrapped trajectories. Once the update is performed, the second half of the episodes is unrolled using the updated policy, forming a second update buffer used for a second on-policy update. For convenience, in the remainder of this paper, we call the first kind end-of-episode (EOE) bootstrapping, while the second kind is designated as partial-trajectory (PT) bootstrapping. Regarding the implementation of these features, adding EOE bootstrapping to an existing actor-critic code requires only minimal modifications, while PT bootstrapping requires a larger amount of modifications in the unrolling process.

In the context of real environments, this approach leads to an important flexibility, as (i) it does not need to collect full episodes to perform updates, (ii) it allows for better exploitation of parallel environments, and (iii) it preserves the on-policiness of the PPO algorithm. While it is important to notice that this method relies on a proper evaluation of the value function at the states at which bootstrapping is applied, our experiments show that the learning of the value function in the early steps of the process is sufficient for the method to bring an important benefit over the vanilla approach.

3. Continuous Flow Control Application

To illustrate the interest of the approach introduced in the previous section, a continuous flow control case from the literature is considered. To present meaningful results, the authors chose an environment for which the CPU cost of the unrolling is significantly higher than the training of the agent (typically around $96\%$ of the total CPU time). To illustrate, the repartition of the CPU time of these two cases is compared with that of the well-known pendulum-v1 environment in Figure 2. This section is devoted to the description of the cases, while the corresponding results are shown in Section 4.

3.1. Control of Instabilities in a Falling Fluid Film

The considered case concerns the control of growing instabilities developing in a 1D falling fluid film perturbed with random noise, for which a simplified, two-equations model for this setup was proposed in 1967 by Shkadov [28]. Although it was found to lack some physical consistency [29], this model displays interesting spatio-temporal dynamics while remaining acceptably cheap to integrate numerically. It simultaneously evolves the flow rate q as well as the fluid height h as:

$$\begin{array}{cc}\hfill {\partial }_{t}h& =-{\partial }_{x}q,\hfill \\ \hfill {\partial }_{t}q& =-\frac{6}{5}{\partial }_x\left(\frac{q^2}{h}\right)+\frac{1}{5\delta }\left(h\left(1+{\partial }_{xxx}h\right)-\frac{q}{h^2}\right),\hfill \end{array}$$

(1)

with all the physics of the problem being condensed in the $\delta$ parameter:

$$\delta =\frac{1}{15}{\left(\frac{3{Re}^2}{W}\right)}^{\frac{1}{3}},$$

(2)

where $Re$ and W are the Reynolds and the Weber numbers, respectively, defined on the flat-film thickness and the flat-film average velocity [30]. The system (1) is solved on a 1D domain of length L, with the following initial and boundary conditions:

$$\begin{array}{cc}\hfill q(x,0)& =1\mathrm{and}h(x,0)=1,\hfill \\ \hfill q(0,t)& =1\mathrm{and}h(0,t)=1+\mathcal{U}(-\epsilon ,\epsilon ),\hfill \\ \hfill {\partial }_{x}q(L,t)& =0\mathrm{and}{\partial }_{x}h(L,t)=0,\hfill \end{array}$$

(3)

with $\epsilon \ll 1$ being the noise level. As shown in Figure 3, the introduction of a random uniform noise at the inlet triggers the development of exponentially growing instabilities (blue region) which eventually transition to a pseudo-periodic behavior (orange region). Then, the periodicity of the waves break, and the instabilities turn into into pulse-like structures, presenting a steep front preceded by small ripples [31]. It is observed that some of these steep pulses, called solitary pulses, travel faster than others, and can capture upstream pulses in coalescence events. The dynamics of these solitary pulses are fully determined by the $\delta$ parameter, while the location of the transition regions also depends on the inlet noise level [30].

The control environment proposed here is re-implemented based on the original publication of Belus et al. [23], although with some significant differences, noted hereafter. It is important to notice that the translational invariance feature introduced in [23] is not exploited here. Equations (1) are discretized using a finite difference approach. Due to the existence of sharp gradients, the convective terms are discretized using a TVD scheme with a minmod flux limiter. The discretized third-order derivative is obtained by chaining a second-order centered difference for the second derivative, chained with a second-order forward difference, leading a second-order approximation. Finally, the time derivatives are discretized using a second-order Adams-Bashforth method. The convergence of the numerical discretization is tested on a manufactured solution in Appendix B.

The control of the system (1) is performed by adding a forcing term $\delta q_j$ to the equation driving the temporal evolution of the flow rate. In practice, this is achieved by adding localized jets at certain positions in the domain, as shown in Figure 4, whose strengths are to be controlled by the DRL agent. The first jet is positioned by default at $x_0=150$, with jet spacing being by default set to $\Delta x_{\mathrm{jets}}=10$, similarly to [23]. To save computational time, the length of the domain is a function of the number of jets $n_{\mathrm{jets}}$ and their spacing:

$$L=L_0+\left(n_{\mathrm{jets}}+2\right)\Delta x_{\mathrm{jets}}.$$

(4)

By default, $L_0=150$ (which corresponds to the start of the pseudo-periodic region for $\delta =0.1$), and $n_{\mathrm{jets}}$ is set equal to 1. The spatial discretization step is set as $\Delta x=0.5$, while the numerical time step is $\Delta t=0.005$. The inlet noise level is set as $\epsilon =5\times {10}^{-4}$, similarly to [23]. The injected flow rate $\delta q_j$ has the following form:

$$\delta q_j(x,t)=A{u}_j\left(t\right)\frac{4\left(x-x_j^l\right)\left(x_j^r-x\right)}{{\left(x_j^r-x_j^l\right)}^2},$$

(5)

with $A=5$ an ad-hoc non-dimensional amplitude factor, $x_j^l$ and $x_j^r$ the left and right limits of jet j, and $u_j\left(t\right)\in [-1,1]$ the action provided by the agent. Expression (5) corresponds to a parabolic profile of the jet in x, such that the injected flow rate drops to 0 on the boundaries of each jet. The jet width $x_j^r-x_j^l$ is set equal to 4, similarly to [23]. The time dependance of $u\left(t\right)$ is implemented as a saturated linear variation from an action to the next one, in the form

$$u_j\left(t\right)=(1-\alpha \left(t\right))u_j^{n-1}+\alpha \left(t\right)u_j^n,\mathrm{with}\alpha \left(t\right)=min\left(\frac{t-t_n}{\Delta t_{\mathrm{int}}},1\right),$$

(6)

Hence, when the actor provides a new action to the environment at time $t=t_n$, the real imposed action is a linear interpolation between the previous action $u_j^{n-1}$ and the new action $u_j^n$ over a time $\Delta t_{\mathrm{int}}$ (here taken equal to $0.01$ time units); after that, the new action is imposed over the remaining action time $\Delta t_{\mathrm{const}}$ (here taken equal to $0.04$ time units). The total action time-step is therefore $\Delta t_{\mathrm{act}}=\Delta t_{\mathrm{int}}+\Delta t_{\mathrm{const}}$, whose value is therefore equal to $0.05$ time units. The total episode time is fixed to 20 time units, corresponding to 400 actions.

The observations provided to the agent are the mass flow rates collected in the union of regions $A_{\mathrm{obs}}^j$ of length $l_{\mathrm{obs}}=10$ located upstream of each jet, as shown in Figure 4. Contrarily to the original article, the flow rates of this region are not provided to the agent, and the observations are not clipped. The reward for each jet j is computed on a region $A_{\mathrm{rwd}}^j$ of length $l_{\mathrm{rwd}}=10$ located downstream of it (see Figure 4), the global reward consisting of a weighted sum of each individual reward:

$$r\left(t\right)=-\frac{1}{l_{\mathrm{rwd}}{n}_{\mathrm{jets}}}\sum _{j=0}^{n_{\mathrm{jets}}-1}\sum _{x\in A_{\mathrm{rwd}}^j}{(h(x,t)-1)}^2$$

(7)

Finally, each episode starts by randomly loading a fully developed initial state from a pre-computed set. The latter were obtained by solving the uncontrolled equations from an initial flat film configuration during a time $t_{\mathrm{init}}$ and comprise between 200 and 220 time units.

3.2. Default PPO Parameters

The default parameters used for the present study are presented in

Table 1. Default parameters used in this study.

–	agent type	PPO-clip
$\gamma$	discount factor	0.99
${\lambda }_a$	actor learning rate	5 × 10−4
${\lambda }_c$	critic learning rate	2 × 10−3
–	optimizer	adam
–	weights initialization	orthogonal
–	activation (hidden layers)	relu
–	activation (actor final layer)	tanh, sigmoid
–	activation (critic final layer)	linear
$ϵ$	PPO clip value	0.2
$\beta$	entropy bonus	0.01
g	gradient clipping value	0.1
–	actor network	$[64,[\left[64\right],\left[64\right]\left]\right]$
–	critic network	$[64,64]$
–	observation normalization	yes
–	observation clipping	no
–	advantage type	GAE
${\lambda }_{\mathrm{GAE}}$	bias-variance trade-off	0.99
–	advantage normalization	yes

. A PPO agent is used with separate networks for the actor and the critic, the actions being drawn from a multivariate normal law with diagonal covariance matrix. While the critic network is a simple feedforward network with two hidden layers of size 64, the actor network is made of a trunk of size 64, with two branches composed of a single layer, each of size 64. The first branch is terminated using a tanh layer, used to output the mean of the normal distribution, while the second branch ends with a sigmoid layer, used to output the standard deviation of the distribution. The actions drawn from the corresponding distribution are clipped in ${[-1,1]}^d$ before being mapped to their adequate physical range. The generalized advantage estimate [27] is used, and the advantage vectors are normalized per rollout. Additionally, we underline that the current parallel implementation is based on the message-passing interface (MPI), which led to improved parallel speedups over shared-memory approach.

4. Results

In this section, we evaluate the interest of bootstrapping, as well as the performance of the proposed parallel paradigm against the canonical parallel approach. First, we simply compare the score curves obtained from sequential learning, with and without the end-of-episode (EOE) bootstrapping step. Then, we investigate the performance of the partial-trajectory (PT) bootstrapping parallel technique against the standard approach. Since they do not represent the core of this contribution, results from the solved environment are proposed in Appendix C.

4.1. End-of-Episode Bootstrapping

First, we consider the sole impact of EOE bootstrapping on the agent training. To do so, we compare the score curves obtained by training an agent in sequential mode on both environments, with a “regular” ending (i.e., no EOE bootstrapping step) and with a bootstrapped ending. As can be observed in Figure 5, EOE bootstrapping accelerates the convergence of the agent while also reducing the variability in performance between the different runs. On the Shakdov environment, it almost cuts by half the number of required transitions to reach the maximal score. To illustrate further the benefits of EOE bootstrapping, results on standard gym environments are also presented in Appendix A. Similar conclusions are drawn from these additional examples.

To better understand the effects of the EOE bootstrapping, the plots of the value loss and value estimate along the course of training are proposed in Figure 6a,b, respectively. A significantly lower value loss is observed, indicating that the EOE bootstrapping, by solving the credit assignment issue [22], induces a smoother value landscape for the critic to learn. This results in higher value estimates, which is expected due to the nature of the EOE bootstrapping procedure.

4.2. Bootstrap-Based Parallelism

This section focuses on the interest of the partial-trajectory (PT) bootstrapping technique for parallel transitions collection proposed in Section 2.4. To evaluate its interest, we consider the score curves obtained on the Shkadov environment in different configurations, the number of parallel environments ranging from 1 to 64 (see Figure 7). First, we solve it with no bootstrapping at all (Figure 7a,b), then with EOE bootstrapping only (Figure 7c,b), then with EOE and PT bootstrapping (Figure 7e,f). In all three cases, the score curves are plotted both against walltime and transitions in order to visualize the parallel speedup obtained, as well as the relative performances using different numbers of parallel environments. For the clarity of the following discussion, we remind the reader that $n_{\mathrm{env}}$ designates the number of parallel environments used to gather transitions, and $n_{\mathrm{update}}$ the number of full episodes to perform an update of the agent (here equal to 8). Moreover, we introduce the notation $s_{n\to m}^{\mathrm{M}}$ to designate the speedup observed for a parallel approach M when using m parallel environments instead of n. Hence, for a perfect speedup, $s_{n\to m}^{\mathrm{M}}=\frac{m}{n}$.

For ${\mathit{n}}_{\mathbf{env}}\le {\mathit{n}}_{\mathbf{update}}$,the performance remains stable in each of the three configurations. This is expected, as the use of parallel environments only modifies the pace at which the updates occur, but the constitution of the update buffers is the same as it would have been for $n_{\mathrm{env}}=1$. Yet, the use of EOE bootstrapping leads to a faster convergence than the regular case, as was already observed in previous section. Moreover, as PT bootstrapping does not occur when full episodes are used, Figure 7d,f present similar results for $n_{\mathrm{env}}\le 8$;

For ${\mathit{n}}_{\mathbf{env}}>{\mathit{n}}_{\mathbf{update}}$, a rapid decrease in convergence speed and final score is observed for the regular approach, with $n_{\mathrm{env}}>16$, resulting in very poor performance (Figure 7b). This illustrates the reasons that motivated the present contribution, i.e., that the standard parallel paradigm results in impractical constraints, which prevents massive environment parallelism. Introducing EOE bootstrapping (Figure 7d) improves the situation by (i) generally speeding up the convergence, and (ii) improving the final performance of the agents, although the final score obtained for $n_{\mathrm{env}}=32$ remains sub-optimal, while that of $n_{\mathrm{env}}=64$ is poor. Additionally, the “flat steps” phenomenon described in [18] clearly appears for $n_{\mathrm{env}}=32$ and 64, with the length of the steps being roughly equal to the number of transitions unrolled between two updates of the agent. When adding PT bootstrapping (Figure 7f), a clear improvement in the convergence speed is observed even for large $n_{\mathrm{env}}$ values, and the gap in final performance significantly reduces. The flat steps phenomenon is still observed in the early stages of learning for $n_{\mathrm{env}}=32$ and 64, although with significantly reduced intensity.

Similarly to [18], we observe decent speedups for $n_{\mathrm{env}}\le n_{\mathrm{update}}$, with $s_{1\to 8}^{\mathrm{EOE}+\mathrm{PT}}=7.6$, against $s_{1\to 8}^{\mathrm{regular}}=6.9$. This difference is attributed to the additional buffering overhead required in the regular approach, as more transitions are unrolled and stored between each update compared to PT bootstrapping. For higher numbers of parallel environments, we measure $s_{1\to 32}^{\mathrm{EOE}+\mathrm{PT}}=25.4$ against $s_{1\to 32}^{\mathrm{regular}}=17.7$, and $s_{1\to 64}^{\mathrm{EOE}+\mathrm{PT}}=42.4$ against $s_{1\to 64}^{\mathrm{regular}}=18.4$. Again, the excessive memory and buffering requirements of the regular case are the most probable cause of this discrepancy, as is evidenced by the fact that $s_{1\to 64}^{\mathrm{regular}}\simeq s_{1\to 32}^{\mathrm{regular}}$. In the present case, we underline that speedups could probably be improved by replacing the computation of a random initial state at each reset step of the environment by the loading of pre-computed initial states from files.

Hence, the introduction of EOE and PT bootstrapping roughly enables the use of four times more parallel environments than with the vanilla parallelism, thus reducing the resolution time of the Shkadov environment from nearly 1.5 h to approximately 2 min while retaining the same final performance.

5. Conclusions

In the present contribution, we introduced a bootstrapped partial trajectory approach for parallel environments, in order to speed up learning for deep reinforcement learning agents while retaining their on-policiness. The proposed method was tested on a CPU-intensive flow control case from the literature, bringing multiple improvements over regular approaches such as (i) faster convergence, (ii) improved performance for $n_{\mathrm{env}}>n_{\mathrm{update}}$, (iii) improved parallel speedups, (iv) increased flexibility regarding the compatibility of $n_{\mathrm{env}}$ and $n_{\mathrm{update}}$, and (v) preserved on-policiness. The new parallel paradigm roughly allowed for the safe exploitation of four times more parallel environments than the vanilla approach, and speedups as high as 42 were measured. Such techniques, coupled with an efficient parallelism at the solver level, open the door to the control of more complex, resource-demanding environments, thus pushing forward the current limits of DRL-based fluid flow control.