diff --git "a/abs_29K_G/test_abstract_long_2405.00987v1.json" "b/abs_29K_G/test_abstract_long_2405.00987v1.json"
new file mode 100644--- /dev/null
+++ "b/abs_29K_G/test_abstract_long_2405.00987v1.json"
@@ -0,0 +1,261 @@
+{
+    "url": "http://arxiv.org/abs/2405.00987v1",
+    "title": "S$^2$AC: Energy-Based Reinforcement Learning with Stein Soft Actor Critic",
+    "abstract": "Learning expressive stochastic policies instead of deterministic ones has\nbeen proposed to achieve better stability, sample complexity, and robustness.\nNotably, in Maximum Entropy Reinforcement Learning (MaxEnt RL), the policy is\nmodeled as an expressive Energy-Based Model (EBM) over the Q-values. However,\nthis formulation requires the estimation of the entropy of such EBMs, which is\nan open problem. To address this, previous MaxEnt RL methods either implicitly\nestimate the entropy, resulting in high computational complexity and variance\n(SQL), or follow a variational inference procedure that fits simplified actor\ndistributions (e.g., Gaussian) for tractability (SAC). We propose Stein Soft\nActor-Critic (S$^2$AC), a MaxEnt RL algorithm that learns expressive policies\nwithout compromising efficiency. Specifically, S$^2$AC uses parameterized Stein\nVariational Gradient Descent (SVGD) as the underlying policy. We derive a\nclosed-form expression of the entropy of such policies. Our formula is\ncomputationally efficient and only depends on first-order derivatives and\nvector products. Empirical results show that S$^2$AC yields more optimal\nsolutions to the MaxEnt objective than SQL and SAC in the multi-goal\nenvironment, and outperforms SAC and SQL on the MuJoCo benchmark. Our code is\navailable at:\nhttps://github.com/SafaMessaoud/S2AC-Energy-Based-RL-with-Stein-Soft-Actor-Critic",
+    "authors": "Safa Messaoud, Billel Mokeddem, Zhenghai Xue, Linsey Pang, Bo An, Haipeng Chen, Sanjay Chawla",
+    "published": "2024-05-02",
+    "updated": "2024-05-02",
+    "primary_cat": "cs.LG",
+    "cats": [
+        "cs.LG"
+    ],
+    "label": "Original Paper",
+    "paper_cat": "Model AND Based AND Reinforcement AND Learning",
+    "gt": "Learning expressive stochastic policies instead of deterministic ones has\nbeen proposed to achieve better stability, sample complexity, and robustness.\nNotably, in Maximum Entropy Reinforcement Learning (MaxEnt RL), the policy is\nmodeled as an expressive Energy-Based Model (EBM) over the Q-values. However,\nthis formulation requires the estimation of the entropy of such EBMs, which is\nan open problem. To address this, previous MaxEnt RL methods either implicitly\nestimate the entropy, resulting in high computational complexity and variance\n(SQL), or follow a variational inference procedure that fits simplified actor\ndistributions (e.g., Gaussian) for tractability (SAC). We propose Stein Soft\nActor-Critic (S$^2$AC), a MaxEnt RL algorithm that learns expressive policies\nwithout compromising efficiency. Specifically, S$^2$AC uses parameterized Stein\nVariational Gradient Descent (SVGD) as the underlying policy. We derive a\nclosed-form expression of the entropy of such policies. Our formula is\ncomputationally efficient and only depends on first-order derivatives and\nvector products. Empirical results show that S$^2$AC yields more optimal\nsolutions to the MaxEnt objective than SQL and SAC in the multi-goal\nenvironment, and outperforms SAC and SQL on the MuJoCo benchmark. Our code is\navailable at:\nhttps://github.com/SafaMessaoud/S2AC-Energy-Based-RL-with-Stein-Soft-Actor-Critic",
+    "main_content": "INTRODUCTION S!AC (ours) SQL (Haarnoja et al., ICML 17) SAC (Haarnoja et al., ICML 18) Explicit entropy evaluation  Num. SVGD steps = 0 Figure 1: Comparing S2AC to SQL and SAC. S2AC with a parameterized policy is reduced to SAC if the number of SVGD steps is 0. SQL becomes equivalent to S2AC if the entropy is evaluated explicitly with our derived formula. MaxEnt RL (Todorov, 2006; Ziebart, 2010; Haarnoja et al., 2017; Kappen, 2005; Toussaint, 2009; Theodorou et al., 2010; Abdolmaleki et al., 2018; Haarnoja et al., 2018a; Vieillard et al., 2020) has been proposed to address challenges hampering the deployment of RL to real-world applications, including stability, sample efficiency (Gu et al., 2017), and robustness (Eysenbach & Levine, 2022). Instead of learning a deterministic policy, as in classical RL (Sutton et al., 1999; Schulman et al., 2017; Silver et al., 2014; Lillicrap et al., 2015), MaxEnt RL learns a stochastic policy that captures the intricacies of the action space. This enables better exploration during training and eventually better robustness to environmental perturbations at test time, i.e., the agent learns multimodal action space distributions which enables picking the next best action in case a perturbation prevents the execution of the optimal one. To achieve this, MaxEnt RL models the policy using the expressive family of EBMs (LeCun et al., 2006). This translates into learning policies that maximize the sum of expected future reward and expected future entropy. However, estimating the entropy of such complex distributions remains an open problem. To address this, existing approaches either use tricks to go around the entropy computation or make limiting assumptions on the policy. This results in either poor scalability or convergence to suboptimal solutions. For example, SQL (Haarnoja et al., 2017) implicitly incorporates entropy in the Q-function computation. This requires using importance sampling, which results in high variability and hence poor training stability and limited scalability to high dimensional action spaces. SAC (Haarnoja 1 arXiv:2405.00987v1  [cs.LG]  2 May 2024 \fPublished as a conference paper at ICLR 2024 \u03c0(\"|$!) \u03c0(\"|$\") STAC SQL SAC !! !\" S!AC Figure 2: S2AC learns a more optimal solution to the MaxEnt RL objective than SAC and SQL. We design a multigoal environment where an agent starts from the center of the 2-d map and tries to reach one of the three goals (G1, G2, and G3). The maximum expected future reward (level curves) is the same for all the goals but the expected future entropy is different (higher on the path to G2/G3): the action distribution \u03c0(a|s) is bi-modal on the path to the left (G2 and G3) and unimodal to the right (G1). Hence, we expect the optimal policy for the MaxEnt RL objective to assign more weights to G2 and G3. We visualize trajectories (in blue) sampled from the policies learned using SAC, SQL, and S2AC. SAC quickly commits to a single mode due to its actor being tied to a Gaussian policy. Though SQL also recovers the three modes, the trajectories are evenly distributed. S2AC recovers all the modes and approaches the left two goals more frequently. This indicates that it successfully maximizes not only the expected future reward but also the expected future entropy. et al., 2018a), on the other hand, follows a variational inference procedure by fitting a Gaussian distribution to the EBM policy. This enables a closed-form evaluation of the entropy but results in a suboptimal solution. For instance, SAC fails in environments characterized by multimodal action distributions. Similar to SAC, IAPO (Marino et al., 2021) models the policy as a uni-modal Gaussian. Instead of optimizing a MaxEnt objective, it achieves multimodal policies by learning a collection of parameter estimates (mean, variance) through different initializations for different policies. To improve the expressiveness of SAC, SSPG (Cetin & Celiktutan, 2022) and SAC-NF (Mazoure et al., 2020) model the policy as a Markov chain with Gaussian transition probabilities and as a normalizing flow (Rezende & Mohamed, 2015), respectively. However, due to training stability issues, the reported results in Cetin & Celiktutan (2022) show that though both models learn multi-modal policies, they fail to maximize the expected future entropy in positive rewards setups. We propose a new algorithm, S2AC, that yields a more optimal solution to the MaxEnt RL objective. To achieve expressivity, S2AC models the policy as a Stein Variational Gradient Descent (SVGD) (Liu, 2017) sampler from an EBM over Q-values (target distribution). SVGD proceeds by first sampling a set of particles from an initial distribution, and then iteratively transforming these particles via a sequence of updates to fit the target distribution. To compute a closed-form estimate of the entropy of such policies, we use the change-of-variable formula for pdfs (Devore et al., 2012). We prove that this is only possible due to the invertibility of the SVGD update rule, which does not necessarily hold for other popular samplers (e.g., Langevin Dynamics (Welling & Teh, 2011)). While normalizing flow models (Rezende & Mohamed, 2015) are also invertible, SVGD-based policy is more expressive as it encodes the inductive bias about the unnormalized density and incorporates a dispersion term to encourage multi-modality, whereas normalizing flows encode a restrictive class of invertible transformations (with easy-to-estimate Jacobian determinants). Moreover, our formula is computationally efficient and only requires evaluating first-order derivatives and vector products. To improve scalability, we model the initial distribution of the SVGD sampler as an isotropic Gaussian and learn its parameters, i.e., mean and standard deviation, end-to-end. We show that this results in faster convergence to the target distribution, i.e., fewer SVGD steps. Intuitively, the initial distribution learns to contour the high-density region of the target distribution while the SVGD updates result in better and faster convergence to the modes within that region. Hence, our approach is as parameter efficient as SAC, since the SVGD updates do not introduce additional trainable parameters. Note that S2AC can be reduced to SAC when the number of SVGD steps is zero. Also, SQL becomes equivalent to S2AC if the entropy is computed explicitly using our formula (the policy in SQL is an amortized SVGD sampler). Beyond RL, the backbone of S2AC is a new variational inference algorithm with a more expressive and scalable distribution characterized by a closed-form entropy estimate. We believe that this variational distribution can have a wider range of exciting applications. We conduct extensive empirical evaluations of S2AC from three aspects. We start with a sanity check on the merit of our derived SVGD-based entropy estimate on target distributions with known entropy values (e.g., Gaussian) or log-likelihoods (e.g., Gaussian Mixture Models) and assess its 2 \fPublished as a conference paper at ICLR 2024 sensitivity to different SVGD parameters (kernel, initial distribution, number of steps and number of particles). We observe that its performance depends on the choice of the kernel and is robust to variations of the remaining parameters. In particular, we find out that the kernel should be chosen to guarantee inter-dependencies between the particles, which turns out to be essential for invertibility. Next, we assess the performance of S2AC on a multi-goal environment (Haarnoja et al., 2017) where different goals are associated with the same positive (maximum) expected future reward but different (maximum) expected future entropy. We show that S2AC learns multimodal policies and effectively maximizes the entropy, leading to better robustness to obstacles placed at test time. Finally, we test S2AC on the MuJoCo benchmark (Duan et al., 2016). S2AC yields better performances than the baselines on four out of the five environments. Moreover, S2AC shows higher sample efficiency as it tends to converge with fewer training steps. These results were obtained from running SVGD for only three steps, which results in a small overhead compared to SAC during training. Furthermore, to maximize the run-time efficiency during testing, we train an amortized SVGD version of the policy to mimic the SVGD-based policy. Hence, this reduces inference to a forward pass through the policy network without compromising the performance. 2 PRELIMINARIES 2.1 SAMPLERS FOR ENERGY-BASED MODELS In this work, we study three representative methods for sampling from EBMs: (1) Stochastic Gradient Langevin Dynamics (SGLD) & Deterministic Langevin Dynamics (DLD) (Welling & Teh, 2011), (2) Hamiltonian Monte Carlo (HMC) (Neal et al., 2011), and (3) Stein Variational Gradient Descent (SVGD) (Liu & Wang, 2016). We review SVGD here since it is the sampler we eventually use in S2AC, and leave the rest to Appendix C.1. SVGD is a particle-based Bayesian inference algorithm. Compared to SGLD and HMC which have a single particle in their dynamics, SVGD operates on a set of particles. Specifically, SVGD samples a set of m particles {aj}m j=1 from an initial distribution q0 which it then transforms through a sequence of updates to fit the target distribution. Formally, at every iteration l, SVGD applies a form of functional gradient descent \u2206f that minimizes the KL-divergence between the target distribution p and the proposal distribution ql induced by the particles, i.e., the update rule for the ith particles is: al+1 i = al i + \u03f5\u2206f(al i) with \u2206f(al i) = Eal j\u223cql \u0002 k(al i, al j)\u2207al j log p(al j) + \u2207al jk(al i, al j) \u0003 . (1) Here, \u03f5 is the step size and k(\u00b7, \u00b7) is the kernel function, e.g., the RBF kernel: k(ai, aj) = exp(||ai \u2212 aj||2/2\u03c32). The first term within the gradient drives the particles toward the high probability regions of p, while the second term serves as a repulsive force to encourage dispersion. 2.2 MAXIMUM-ENTROPY RL We consider an infinite horizon Markov Decision Process (MDP) defined by a tuple (S, A, p, r), where S is the state space, A is the action space and p : S \u00d7 A \u00d7 S \u2192[0, \u221e] is the state transition probability modeling the density of the next state st+1 \u2208S given the current state st \u2208S and action at \u2208A. Additionally, we assume that the environment emits a bounded reward function r \u2208[rmin, rmax] at every iteration. We use \u03c1\u03c0(st) and \u03c1\u03c0(st, at) to denote the state and state-action marginals of the trajectory distribution induced by a policy \u03c0(at|st). We consider the setup of continuous action spaces Lazaric et al. (2007); Lee et al. (2018); Zhou & Lu (2023). MaxEnt RL (Todorov, 2006; Ziebart, 2010; Rawlik et al., 2012) learns a policy \u03c0\u2217(at|st), that instead of maximizing the expected future reward, maximizes the sum of the expected future reward and entropy: \u03c0\u2217= arg max\u03c0 X t \u03b3tE(st,at)\u223c\u03c1\u03c0 \u0002 r(st, at) + \u03b1H(\u03c0(\u00b7|st)) \u0003 , (2) where \u03b1 is a temperature parameter controlling the stochasticity of the policy and H(\u03c0(\u00b7|st)) is the entropy of the policy at state st. The conventional RL objective can be recovered for \u03b1 = 0. Note that the MaxEnt RL objective above is equivalent to approximating the policy, modeled as an EBM over Q-values, by a variational distribution \u03c0(at|st) (see proof of equivalence in Appendix D), i.e., \u03c0\u2217= arg min\u03c0 X t Est\u223c\u03c1\u03c0 \u0002 DKL \u0000\u03c0(\u00b7|st)\u2225exp(Q(st, \u00b7)/\u03b1)/Z \u0001\u0003 , (3) where DKL is the KL-divergence and Z is the normalizing constant. We now review two landmark MaxEnt RL algorithms: SAC (Haarnoja et al., 2018a) and SQL (Haarnoja et al., 2017). SAC is an actor-critic algorithm that alternates between policy evaluation, i.e., evaluating the Q-values for a policy \u03c0\u03b8(at|st): Q\u03d5(st, at) \u2190r(st, at) + \u03b3 Est+1,at+1\u223c\u03c1\u03c0\u03b8 \u0002 Q\u03d5(st+1, at+1) + \u03b1H(\u03c0\u03b8(\u00b7|st+1)) \u0003 (4) 3 \fPublished as a conference paper at ICLR 2024 and policy improvement, i.e., using the updated Q-values to compute a better policy: \u03c0\u03b8 = arg max\u03b8 X t Est,at\u223c\u03c1\u03c0\u03b8 \u0002 Q\u03d5(at, st) + \u03b1H(\u03c0\u03b8(\u00b7|st)) \u0003 . (5) SAC models \u03c0\u03b8 as an isotropic Gaussian, i.e., \u03c0\u03b8(\u00b7|s) = N(\u00b5\u03b8, \u03c3\u03b8I). While this enables computing a closed-form expression of the entropy, it incurs an over-simplification of the true action distribution, and thus cannot represent complex distributions, e.g., multimodal distributions. SQL goes around the entropy computation, by defining a soft version of the value function V\u03d5 = \u03b1 log \u0000 R A exp \u0000 1 \u03b1Q\u03d5(st, a\u2032) \u0001 da\u2032\u0001 . This enables expressing the Q-value (Eq (4)) independently from the entropy, i.e., Q\u03d5(st, at) = r(st, at) + \u03b3Est+1\u223cp[V\u03d5(st+1)]. Hence, SQL follows a soft value iteration which alternates between the updates of the \u201csoft\u201d versions of Q and value functions: Q\u03d5(st, at) \u2190r(st, at) + \u03b3Est+1\u223cp[V\u03d5(st+1)], \u2200(st, at) (6) V\u03d5(st) \u2190\u03b1 log \u0000 R A exp \u0000 1 \u03b1Q\u03d5(st, a\u2032) \u0001 da\u2032\u0001 , \u2200st. (7) Once the Q\u03d5 and V\u03d5 functions converge, SQL uses amortized SVGD Wang & Liu (2016) to learn a stochastic sampling network f\u03b8(\u03be, st) that maps noise samples \u03be into the action samples from the EBM policy distribution \u03c0\u2217(at|st) = exp \u0000 1 \u03b1(Q\u2217(st, at) \u2212V \u2217(st)) \u0001 . The parameters \u03b8 are obtained by minimizing the loss J\u03b8(st) = DKL \u0000\u03c0\u03b8(\u00b7|st)|| exp \u0000 1 \u03b1(Q\u2217 \u03d5(st, \u00b7) \u2212V \u2217 \u03d5 (st)) \u0001 with respect to \u03b8. Here, \u03c0\u03b8 denotes the policy induced by f\u03b8. SVGD is designed to minimize such KL-divergence without explicitly computing \u03c0\u03b8. In particular, SVGD provides the most greedy direction as a functional \u2206f\u03b8(\u00b7, st) (Eq (1)) which can be used to approximate the gradient \u2202J\u03b8/\u2202at. Hence, the gradient of the loss J\u03b8 with respect to \u03b8 is: \u2202J\u03b8(st)/\u2202\u03b8 \u221dE\u03be \u0002 \u2206f\u03b8(\u03be, st)\u2202f\u03b8(\u03be, st)/\u2202\u03b8 \u0003 . Note that the integral in Eq (7) is approximated via importance sampling, which is known to result in high variance estimates and hence poor scalability to high dimensional action spaces. Moreover, amortized generation is usually unstable and prone to mode collapse, an issue similar to GANs. Therefore, SQL is outperformed by SAC Haarnoja et al. (2018a) on benchmark tasks like MuJoCo. 3 APPROACH We introduce S2AC, a new actor-critic MaxEnt RL algorithm that uses SVGD as the underlying actor to generate action samples from policies represented using EBMs. This choice is motivated by the expressivity of distributions that can be fitted via SVGD. Additionally, we show that we can derive a closed-form entropy estimate of the SVGD-induced distribution, thanks to the invertibility of the update rule, which does not necessarily hold for other EBM samplers. Besides, we propose a parameterized version of SVGD to enable scalability to high-dimensional action spaces and nonsmooth Q-function landscapes. S2AC is hence capable of learning a more optimal solution to the MaxEnt RL objective (Eq (2)) as illustrated in Figure 2. 3.1 STEIN SOFT ACTOR CRITIC Like SAC, S2AC performs soft policy iteration which alternates between policy evaluation and policy improvement. The difference is that we model the actor as a parameterized sampler from an EBM. Hence, the policy distribution corresponds to an expressive EBM as opposed to a Gaussian. Critic. The critic\u2019s parameters \u03d5 are obtained by minimizing the Bellman loss as traditionally: \u03d5\u2217= arg min\u03d5 E(st,at)\u223c\u03c1\u03c0\u03b8 \u0002 (Q\u03d5(st, at) \u2212\u02c6 y)2\u0003 , (8) with the target \u02c6 y = rt(st, at) + \u03b3E(st+1,at+1)\u223c\u03c1\u03c0 \u0002 Q \u00af \u03d5(st+1, at+1) + \u03b1H(\u03c0(\u00b7|st+1)) \u0003 . Here \u00af \u03d5 is an exponentially moving average of the value network weights (Mnih et al., 2015). Actor as an EBM sampler. The actor is modeled as a sampler from an EBM over the Q-values. To generate a set of valid actions, the actor first samples a set of particles {a0} from an initial distribution q0 (e.g., Gaussian). These particles are then updated over several iterations l \u2208[1, L], i.e., {al+1} \u2190{al} + \u03f5h({al}, s) following the sampler dynamics characterized by a transformation h (e.g., for SVGD, h = \u2206f in Eq (1)). If q0 is tractable and h is invertible, it\u2019s possible to compute a closed-form expression of the distribution of the particles at the lth iteration via the change of variable formula Devore et al. (2012): ql(al|s) = ql\u22121(al\u22121|s) \f \fdet(I + \u03f5\u2207alh(al, s)) \f \f\u22121 , \u2200l \u2208[1, L]. In this case, the policy is represented using the particle distribution at the final step L of the sampler dynamics, i.e., \u03c0(a|s) = qL(aL|s) and the entropy can be estimated by averaging log qL(aL|s) over a set of particles (Section 3.2). We study the invertibility of popular EBM samplers in Section 3.3. 4 \fPublished as a conference paper at ICLR 2024 \ud835\udc4e! ! \ud835\udc4e! \"! \ud835\udc5e!(\ud835\udc4e|\ud835\udc60) \ud835\udc4e! ! \ud835\udc4e! #! \ud835\udc5e!(\ud835\udc4e|\ud835\udc60) S!AC(\ud835\udf19, \ud835\udf03) S!AC(\ud835\udf19) Figure 3: S2AC(\u03d5, \u03b8) achieves faster convergence to the target distribution (in orange) than S2AC(\u03d5) by parameterizing the initial distribution N(\u00b5\u03b8, \u03c3\u03b8) of the SVGD sampler. Parameterized initialization. To reduce the number of steps required to converge to the target distribution (hence reducing computation cost), we further propose modeling the initial distribution as a parameterized isotropic Gaussian, i.e., a0 \u223cN(\u00b5\u03b8(s), \u03c3\u03b8(s)). The parameterization trick is then used to express a0 as a function of \u03b8. Intuitively, the actor would learn \u03b8 such that the initial distribution is close to the target distribution. Hence, fewer steps are required to converge, as illustrated in Figure 3. Note that if the number of steps L = 0, S2AC is reduced to SAC. Besides, to deal with the non-smooth nature of deep Q-function landscapes which might lead to particle divergence in the sampling process, we bound the particle updates to be within a few standard deviations (t) from the mean of the learned initial distribution, i.e., \u2212t\u03c3\u03b8 \u2264al \u03b8 \u2264t\u03c3\u03b8, \u2200l \u2208[1, L]. Eventually, the initial distribution q0 \u03b8 learns to contour the high-density region of the target distribution and the following updates refine it by converging to the spanned modes. Formally, the parameters \u03b8 are computed by minimizing the expected KL-divergence between the policy qL \u03b8 induced by the particles from the sampler and the EBM of the Q-values: \u03b8\u2217=arg max\u03b8Est\u223cD,aL \u03b8 \u223c\u03c0\u03b8 \u0002 Q\u03d5(st, aL \u03b8 ) \u0003 + \u03b1Est\u223cD [H(\u03c0\u03b8(\u00b7|st))] s.t. \u2212t\u03c3\u03b8 \u2264al \u03b8 \u2264t\u03c3\u03b8, \u2200l \u2208[1, L]. (9) Here, D is the replay buffer. The derivation is in Appendix E. Note that the constraint does not truncate the particles as it is not an invertible transformation which then violates the assumptions of the change of variable formula. Instead, we sample more particles than we need and select the ones that stay within the range. We call S2AC(\u03d5, \u03b8) and S2AC(\u03d5) as two versions of S2AC with/without the parameterized initial distribution. The complete S2AC algorithm is in Algorithm 1 of Appendix A. 3.2 A CLOSED-FORM EXPRESSION OF THE POLICY\u2019S ENTROPY A critical challenge in MaxEnt RL is how to efficiently compute the entropy term H(\u03c0(\u00b7|st+1)) in Eq (2). We show that, if we model the policy as an iterative sampler from the EBM, under certain conditions, we can derive a closed-form estimate of the entropy at convergence. Theorem 3.1. Let F : Rn \u2192Rn be an invertible transformation of the form F(a) = a + \u03f5h(a). We denote by qL(aL) the distribution obtained from repeatedly applying F to a set of samples {a0} from an initial distribution q0(a0) over L steps, i.e., aL = F \u25e6F \u25e6\u00b7 \u00b7 \u00b7 \u25e6F(a0). Under the condition \u03f5||\u2207al ih(ai)||\u221e\u226a1, \u2200l \u2208[1, L], the distribution of the particles at the Lth step is: log qL(aL) \u2248log q0(a0) \u2212\u03f5 XL\u22121 l=0 Tr(\u2207alh(al)) + O(\u03f52dL). (10) Here, d is the dimensionality of a, i.e., a \u2208Rd and O(\u03f52dL) is the order of approximation error. Proof Sketch: As F is invertible, we apply the change of variable formula (Appendix C.2) on the transformation F \u25e6F \u25e6\u00b7 \u00b7 \u00b7 F and obtain: log qL(aL) = log q0(a0)\u2212PL\u22121 l=0 log \f \fdet(I + \u03f5\u2207alh(al)) \f \f. Under the assumption \u03f5||\u2207aih(ai)||\u221e\u226a1, we apply the corollary of Jacobi\u2019s formula (Appendix C.3) and get Eq. (10). The detailed proof is in Appendix F. Note that the condition \u03f5||\u2207aih(ai)||\u221e\u226a1 can always be satisfied when we choose a sufficiently small step size \u03f5, or the gradient of h(a) is small, i.e., h(a) is Lipschitz continuous with a sufficiently small constant. It follows from the theorem above, that the entropy of a policy modeled as an EBM sampler (Eq (9)) can be expressed analytically as: H(\u03c0\u03b8(\u00b7|s))=\u2212Ea0 \u03b8\u223cq0 \u03b8 h log qL \u03b8 (aL \u03b8 |s) i \u2248\u2212Ea0 \u03b8\u223cq0 \u03b8 h log q0 \u03b8(a0|s)\u2212\u03f5 XL\u22121 l=0 Tr \u0010 \u2207al \u03b8h(al \u03b8, s) \u0011 i . (11) In the following, we drop the dependency of the action on \u03b8 for simplicity of the notation. 3.3 INVERTIBLE POLICIES Next, we study the invertibility of three popular EBM samplers: SVGD, SGLD, and HMC as well as the efficiency of computing the trace, i.e., Tr(\u2207alh(al, s)) in Eq (10) for the ones that are invertible. Proposition 3.2 (SVGD invertibility). Given the SVGD learning rate \u03f5 and RBF kernel k(\u00b7, \u00b7) with variance \u03c3, if \u03f5 \u226a\u03c3, the update rule of SVGD dynamics defined in Eq (1) is invertible. 5 \fPublished as a conference paper at ICLR 2024 SVGD \u210b(\ud835\udc5e!) = 3.5 DLD \u210b(\ud835\udc5e!) = \u221225.93 SGLD \u210b(\ud835\udc5e!) = \u221211.57 HMC \u210b(\ud835\udc5e!) = \u221254.5 Initial Distribution \ud835\udc5e\" = \ud835\udca9(0, 6\ud835\udc3c) (a) Recovering the GT entropy m \u210b(\ud835\udc5e!) Kernel variance \ud835\udf0e (b) Effect of \u03c3 on H(qL) (\ud835\udc5a, \ud835\udc3f)= (\ud835\udc5a, \ud835\udc3f)= (\ud835\udc5a, \ud835\udc3f)= (\ud835\udc5a, \ud835\udc3f)= \u210b(\ud835\udc5e!) Target Distribution (c) Effect of m and L on H(qL) Figure 4: Entropy evaluation results. Proof Sketch: We use the explicit function theorem to show that the Jacobian \u2207aF(a, s) of the update rule F(a, s) is diagonally dominated and hence invertible. This yields invertibility of F(a, s). See detailed proof in Appendix G.3. Theorem 3.3. The closed-form estimate of log qL(aL|s) for the SVGD based sampler with an RBF kernel k(\u00b7, \u00b7) is log qL(aL|s)\u2248logq0(a0|s)+ \u03f5 m\u03c32 L\u22121 X l=0 m X j=1,al\u0338=al j k(al j, al) \u0010 (al\u2212al j)\u22a4\u2207al jQ(s, al j)+ \u03b1 \u03c32 \u2225al\u2212al j\u22252\u2212d\u03b1 \u0011 . Here, (\u00b7)\u22a4denotes the transpose of a matrix/vector. Note that the entropy does not depend on any matrix computation, but only on vector dot products and first-order vector derivatives. The proof is in Appendix H.1. Intuitively, the derived likelihood is proportional to (1) the concavity of the curvature of the Q-landscape, captured by a weighted average of the neighboring particles\u2019 Q-value gradients and (2) pairwise-distances between the neighboring particles (\u223c\u2225al i\u2212al j\u22252 \u00b7 exp (\u2225al i\u2212al j\u22252)), i.e., the larger the distance the higher is the entropy. We elaborate on the connection between this formula and non-parametric entropy estimators in Appendix B. Proposition 3.4 (SGLD, HMC). The SGLD and HMC updates are not invertible w.r.t. a. Proof Sketch: SGLD is stochastic (noise term) and thus not injective. HMC is only invertible if conditioned on the velocity v. Detailed proofs are in Appendices G.1-G.2. From the above theoretic analysis, we can see that SGLD update is not invertible and hence is not suitable as a sampler for S2AC. While the HMC update is invertible, its derived closed-form entropy involves calculating Hessian and hence computationally more expensive. Due to these considerations, we choose to use SVGD with an RBF kernel as the underlying sampler of S2AC. 4 RESULTS We first evaluate the correctness of our proposed closed-form entropy formula. Then we present the results of different RL algorithms on multigoal and MuJoCo environments. 4.1 ENTROPY EVALUATION This experiment tests the correctness of our entropy formula. We compare the estimated entropy for distributions (with known ground truth entropy or log-likelihoods) using different samplers and study the sensitivity of the formula to different samplers\u2019 parameters. (1) Recovering the ground truth entropy. In Figure 4a, we plot samples (black dots) obtained by SVGD, SGLD, DLD and HMC at convergence to a Gaussian with ground truth entropy H(p) = 3.41, starting from the same initial distribution (leftmost sub-figure). We also report the entropy values computed via Eq.(11). Unlike SGLD, DLD, and HMC, SVGD recovers the ground truth entropy. This empirically supports Proposition 3.4 that SGLD, DLD, and HMC are not invertible. (2) Effect of the kernel variance. Figure 4b shows the effect of different SVGD kernel variances \u03c3, where we use the same initial Gaussian from Figure 4a. We also visualize the particle distributions after L SVGD steps for the different configurations in Figure 9 of Appendix I. We can see that when the kernel variance is too small (e.g., \u03c3 = 0.1), the invertibility is violated, and thus the estimated entropy is wrong even at convergence. On the other extreme when the kernel variance is too large (e.g., \u03c3=100), i.e., when the particles are too scattered initially, the particles do not converge to the target Gaussian due to noisy gradients in the first term of Eq.(1). The best configurations hence lie somewhere in between (e.g., \u03c3\u2208{3, 5, 7}). (3) Effect of SVGD steps and particles. Figure 4c and Figure 10b (Appendix. I) show the behavior of our entropy formula under different configurations of the number of SVGD steps and particles, on two settings: (i) GMM M with an increasing number of components M, and (ii) distributions with increasing ground truth entropy values, i.e., Gaussians with increasing variances \u03c3. Results show that our entropy consistently grows with an increasing M (Figure 4c) and increasing \u03c3 (Figure 10b), even when a small number of SVGD steps and particles is used (e.g., L = 10, m = 10). 6 \fPublished as a conference paper at ICLR 2024 4.2 MULTI-GOAL EXPERIMENTS ! = 0.2 ! = 1 ! = 10 ! = 20 '! '\" (', (( () Multigoal Environment Figure 5: Multigoal env. To check if S2AC learns a better solution to the max-entropy objective (Eq (2)), we design a new multi-goal environment as shown in Figure 5. The agent is a 2D point mass at the origin trying to reach one of the goals (in red). Q-landscapes are depicted by level curves. Actions are bounded in [\u22121, 1] along both axes. Critical states for the analysis are marked with blue crosses. It is built on the multi-goal environment in Haarnoja et al. (2017) with modifications such that all the goals have (i) the same maximum expected future reward (positive) but (ii) different maximum expected future entropy. This is achieved by asymmetrically placing the goals (two goals on the left side and one on the right, leading to a higher expected future entropy on the left side) while assigning the same final rewards to all the goals. The problem setup and hyperparameters are detailed in Appendix J. (1) Multi-modality. Figure 6 visualizes trajectories (blue lines) collected from 20 episodes of S2AC(\u03d5, \u03b8), S2AC(\u03d5), SAC, SQL and SAC-NF (SAC with a normalizing flow policy, Mazoure et al. (2020)) agents (rows) at test time for increasing entropy weights \u03b1 (columns). S2AC and SQL consistently cover all the modes for all \u03b1 values, while this is only achieved by SAC and SAC-NF for large \u03b1 values. Note that, in the case of SAC, this comes at the expense of accuracy. Although normalizing flows are expressive enough in theory, they are known to quickly collapse to local optima in practice Kobyzev et al. (2020). The dispersion term in S2AC encodes an inductive bias to mitigate this issue. (2) Maximizing the expected future entropy. We also see that with increasing \u03b1, more S2AC and SAC-NF trajectories converge to the left goals (G2/G3). This shows both models learn to maximize the expected future entropy. This is not the case for SQL whose trajectory distribution remains uniform across the goals. SAC results do not show a consistent trend. This validates the hypothesis that the entropy term in SAC only helps exploration but does not lead to maximizing future entropy. The quantified distribution over reached goals is in Figure 12 of Appendix J. (3) Robustness/adaptability. To assess the robustness of the learned policies, we place an obstacle (red bar in Figure 7) on the path to G2. We show the test time trajectories of 20 episodes using S2AC, SAC, SQL and SAC-NF agents trained with different \u03b1\u2019s. We observe that, for S2AC and SAC-NF, with increasing \u03b1, more trajectories reach the goal after hitting the obstacles. This is not the case for SAC, where many trajectories hit the obstacle without reaching the goal. SQL does not manage to escape the barrier even with higher \u03b1. Additional results on the (4) effect of parameterization of q0, and the (5) entropy\u2019s effect on the learned Q-landscapes are respectively reported in Figure 11 and Figure 14 of Appendix J. S!AC(\ud835\udf19) SAC SQL S!AC(\ud835\udf19, \ud835\udf03) \ud835\udefc= 0.2 \ud835\udefc= 1 \ud835\udefc= 10 \ud835\udefc= 20 SAC-NF Figure 6: S2AC and SAC-NF learn to maximize the expected future entropy (biased towards G2/G3) while SAC and SQL do not. S2AC consistently recovers all modes, while SAC-NF with smaller \u03b1\u2019s does not, indicating its instability. S!AC(\ud835\udf19) SAC SQL S!AC(\ud835\udf19, \ud835\udf03) \ud835\udefc= 0.2 \ud835\udefc= 1 \ud835\udefc= 10 \ud835\udefc= 20 SAC-NF Figure 7: S2AC and SAC-NF are more robust to perturbations. Obstacle O is placed diagonally at [\u22121, 1]. Trajectories that did and did not reach the goal after hitting O are in green and red, respectively. 7 \fPublished as a conference paper at ICLR 2024 0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 Steps \u00a3105 0 500 1000 1500 2000 2500 3000 3500 Average Return 0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 Steps \u00a3105 \u00b0500 0 500 1000 1500 2000 2500 3000 Average Return 0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 Steps \u00a3105 0 2000 4000 6000 8000 Average Return 0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 Steps \u00a3105 0 500 1000 1500 2000 2500 3000 3500 4000 Average Return PPO SAC-NF DDPG SAC S2AC(\u00a1, \u00b5, \u221a) S2AC(\u00a1, \u00b5) S2AC(\u00a1) SQL 0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 Steps \u00a3105 0 500 1000 1500 2000 2500 3000 3500 4000 Average Return (a) Hopper-v2 (b) Walker2d-v2 (c) HalfCheetah-v2 (d) Ant-v2 (e) Humanoid-v2 (f) Median (g) IQM (h) Mean (i) Optimality Gap (j) P(X>Y) Figure 8: (a)-(e): Performance curves on the MuJoCo benchmark (training). S2AC outperforms SQL and SAC-NF on all environments and SAC on 4 out of 5 environments. (f)-(i): Comparison of Median, IQM, Mean, and Optimality Gap between S2AC and baseline algorithms. (j): The probabilities of S2AC outperforming baseline algorithms. 4.3 MUJOCO EXPERIMENTS We evaluate S2AC on five environments from MuJoCo (Brockman et al., 2016): Hopper-v2, Walker2dv2, HalfCheetah-v2, Ant-v2, and Humanoid-v2. As baselines, we use (1) DDPG (Gu et al., 2017), (2) PPO (Schulman et al., 2015), (3) SQL (Haarnoja et al., 2017), (4) SAC-NF (Mazoure et al., 2020), and (5) SAC (Haarnoja et al., 2018a). Hyperparameters are in Appendix K. (1) Performance and sample efficiency. We train five different instances of each algorithm with different random seeds, with each performing 100 evaluation rollouts every 1000 environment steps. Performance results are in Figure 8(a)-(e). The solid curves correspond to the mean returns over the five trials and the shaded region represents the minimum and maximum. S2AC(\u03d5, \u03b8) is consistently better than SQL and SAC-NF across all the environments and has superior performance than SAC in four out of five environments. Results also show that the initial parameterization was key to ensuring the scalability (S2AC(\u03d5) has poor performance compared to S2AC(\u03d5, \u03b8)). Figure 8(f)-(j) demonstrate the statistical significance of these gains by leveraging statistics from the rliable library (Agarwal et al., 2021) which we detail in Appendix K. Hopper Walker2d HalfCheetah Ant Action dim 3 6 6 8 State dim 11 17 17 111 SAC 0.723 0.714 0.731 0.708 SQL 0.839 0.828 0.815 0.836 S2AC(\u03d5, \u03b8) 3.267 4.622 4.583 5.917 S2AC(\u03d5, \u03b8, \u03c8) 0.850 0.817 0.830 0.837 Table 1: Action selection run-time on MuJoCo. (2) Run-time. We report the run-time of action selection of SAC, SQL, and S2AC algorithms in Table 1. S2AC(\u03d5, \u03b8) run-time increases linearly with the action space. To improve the scalability, we train an amortized version that we deploy at test-time, following (Haarnoja et al., 2017). Specifically, we train a feed-forward deepnet f\u03c8(s, z) to mimic the SVGD dynamics during testing, where z is a random vector that allows mapping the same state to different particles. Note that we cannot use f\u03c8(s, z) during training as we need to estimate the entropy in Eq (11), which depends on the unrolled SVGD dynamics (details in Appendix K). The amortized version S2AC(\u03d5, \u03b8, \u03c8) has a similar run-time to SAC and SQL with a slight tradeoff in performance (Figure 8). 5 RELATED WORK MaxEnt RL (Todorov, 2006; Ziebart, 2010; Rawlik et al., 2012) aims to learn a policy that gets high rewards while acting as randomly as possible. To achieve this, it maximizes the sum of expected future reward and expected future entropy. It is different from entropy regularization (Schulman et al., 2015; O\u2019Donoghue et al., 2016; Schulman et al., 2017) which maximizes entropy at the current time step. It is also different from multi-modal RL approaches (Tang & Agrawal, 2018) which recover different modes with equal frequencies without considering their future entropy. MaxEnt RL has been broadly incorporated in various RL domains, including inverse RL (Ziebart et al., 2008; Finn et al., 2016), stochastic control (Rawlik et al., 2012; Toussaint, 2009), guided policy search (Levine & Koltun, 2013), and off-policy learning (Haarnoja et al., 2018a;b). MaxEnt RL is shown to maximize a lower bound of the robust RL objective (Eysenbach & Levine, 2022) and is hence less sensitive 8 \fPublished as a conference paper at ICLR 2024 to perturbations in state and reward functions. From the variational inference lens, MaxEnt RL aims to find the policy distribution that minimizes the KL-divergence to an EBM over Q-function. The desired family of variational distributions is (1) expressive enough to capture the intricacies of the Q-value landscape (e.g., multimodality) and (2) has a tractable entropy estimate. These two requirements are hard to satisfy. SAC (Haarnoja et al., 2018a) uses a Gaussian policy. Despite having a tractable entropy, it fails to capture arbitrary Q-value landscapes. SAC-GMM (Haarnoja, 2018) extends SAC by modeling the policy as a Gaussian Mixture Model, but it requires an impractical grid search over the number of components. Other extensions include IAPO (Marino et al., 2021) which also models the policy as a uni-modal Gaussian but learns a collection of parameter estimates (mean, variance) through different initializations. While this yields multi-modality, it does not optimize a MaxEnt objective. SSPG (Cetin & Celiktutan, 2022) and SAC-NF (Mazoure et al., 2020) respectively improve the policy expressivity by modeling the policy as a Markov chain with Gaussian transition probabilities and as a normalizing flow. Due to training instability, the reported multi-goal experiments in (Cetin & Celiktutan, 2022) show that, though both models capture multimodality, they fail to maximize the expected future entropy in positive reward setups. SQL (Haarnoja et al., 2017), on the other hand, bypasses the explicit entropy computation altogether via a soft version of value iteration. It then trains an amortized SVGD (Wang & Liu, 2016) sampler from the EBM over the learned Q-values. However, estimating soft value functions requires approximating integrals via importance sampling which is known to have high variance and poor scalability. We propose a new family of variational distributions induced by a parameterized SVGD sampler from the EBM over Q-values. Our policy is expressive and captures multi-modal distributions while being characterized by a tractable entropy estimate. EBMs (LeCun et al., 2006; Wu et al., 2018) are represented as Gibbs densities p(x) = exp E(x)/Z, where E(x) \u2208R is an energy function describing inter-variable dependencies and Z = R exp E(x) is the partition function. Despite their expressiveness, EBMs are not tractable as the partition function requires integrating over an exponential number of configurations. Markov Chain Monte Carlo (MCMC) methods (Van Ravenzwaaij et al., 2018) (e.g., HMC (Hoffman & Gelman, 2014), SGLD (Welling & Teh, 2011)) are frequently used to approximate the partition function via sampling. There have been recent efforts to parameterize these samplers via deepnets (Levy et al., 2017; Gong et al., 2018; Feng et al., 2017) to improve scalability. Similarly to these methods, we propose a parameterized variant of SVGD (Liu & Wang, 2016) as an EBM sampler to enable scalability to highdimensional action spaces. Beyond sampling, we derive a closed-form expression of the sampling distribution as an estimate of the EBM. This yields a tractable estimate of the entropy. This is opposed to previous methods for estimating EBM entropy which mostly rely on heuristic approximation, lower bounds Dai et al. (2017; 2019a), or neural estimators of mutual information (Kumar et al., 2019). The idea of approximating the entropy of EBMs via MCMC sampling by leveraging the change of variable formula was first proposed in Dai et al. (2019b). The authors apply the formula to HMC and LD, which, as we show previously, violate the invertibility assumption. To go around this, they augment the EBM family with the noise or velocity variable for LD and HMC respectively. But the derived log-likelihood of the sampling distribution turns out to be \u2013counter-intuitively\u2013 independent of the sampler\u2019s dynamics and equal to the initial distribution, which is then parameterized using a flow model (details in Appendix B.2). We show that SVGD is invertible, and hence we sample from the original EBM, so that our derived entropy is more intuitive as it depends on the SVGD dynamics. SVGD-augmented RL (Liu & Wang, 2016) has been explored under other RL contexts. Liu et al. (2017) use SVGD to learn a distribution over policy parameters. While this leads to learning diverse policies, it is fundamentally different from our approach as we are interested in learning a single multi-modal policy with a closed-form entropy formula. Castanet et al. (2023); Chen et al. (2021) use SVGD to sample from multimodal distributions over goals/tasks. We go beyond sampling and use SVGD to derive a closed-form entropy formula of an expressive variational distribution. 6",
+    "additional_graph_info": {
+        "graph": [
+            [
+                "Safa Messaoud",
+                "Alexander G. Schwing"
+            ],
+            [
+                "Safa Messaoud",
+                "Zhenghai Xue"
+            ],
+            [
+                "Zhenghai Xue",
+                "Qingpeng Cai"
+            ],
+            [
+                "Zhenghai Xue",
+                "Kun Gai"
+            ]
+        ],
+        "node_feat": {
+            "Safa Messaoud": [
+                {
+                    "url": "http://arxiv.org/abs/2405.00987v1",
+                    "title": "S$^2$AC: Energy-Based Reinforcement Learning with Stein Soft Actor Critic",
+                    "abstract": "Learning expressive stochastic policies instead of deterministic ones has\nbeen proposed to achieve better stability, sample complexity, and robustness.\nNotably, in Maximum Entropy Reinforcement Learning (MaxEnt RL), the policy is\nmodeled as an expressive Energy-Based Model (EBM) over the Q-values. However,\nthis formulation requires the estimation of the entropy of such EBMs, which is\nan open problem. To address this, previous MaxEnt RL methods either implicitly\nestimate the entropy, resulting in high computational complexity and variance\n(SQL), or follow a variational inference procedure that fits simplified actor\ndistributions (e.g., Gaussian) for tractability (SAC). We propose Stein Soft\nActor-Critic (S$^2$AC), a MaxEnt RL algorithm that learns expressive policies\nwithout compromising efficiency. Specifically, S$^2$AC uses parameterized Stein\nVariational Gradient Descent (SVGD) as the underlying policy. We derive a\nclosed-form expression of the entropy of such policies. Our formula is\ncomputationally efficient and only depends on first-order derivatives and\nvector products. Empirical results show that S$^2$AC yields more optimal\nsolutions to the MaxEnt objective than SQL and SAC in the multi-goal\nenvironment, and outperforms SAC and SQL on the MuJoCo benchmark. Our code is\navailable at:\nhttps://github.com/SafaMessaoud/S2AC-Energy-Based-RL-with-Stein-Soft-Actor-Critic",
+                    "authors": "Safa Messaoud, Billel Mokeddem, Zhenghai Xue, Linsey Pang, Bo An, Haipeng Chen, Sanjay Chawla",
+                    "published": "2024-05-02",
+                    "updated": "2024-05-02",
+                    "primary_cat": "cs.LG",
+                    "cats": [
+                        "cs.LG"
+                    ],
+                    "main_content": "INTRODUCTION S!AC (ours) SQL (Haarnoja et al., ICML 17) SAC (Haarnoja et al., ICML 18) Explicit entropy evaluation  Num. SVGD steps = 0 Figure 1: Comparing S2AC to SQL and SAC. S2AC with a parameterized policy is reduced to SAC if the number of SVGD steps is 0. SQL becomes equivalent to S2AC if the entropy is evaluated explicitly with our derived formula. MaxEnt RL (Todorov, 2006; Ziebart, 2010; Haarnoja et al., 2017; Kappen, 2005; Toussaint, 2009; Theodorou et al., 2010; Abdolmaleki et al., 2018; Haarnoja et al., 2018a; Vieillard et al., 2020) has been proposed to address challenges hampering the deployment of RL to real-world applications, including stability, sample efficiency (Gu et al., 2017), and robustness (Eysenbach & Levine, 2022). Instead of learning a deterministic policy, as in classical RL (Sutton et al., 1999; Schulman et al., 2017; Silver et al., 2014; Lillicrap et al., 2015), MaxEnt RL learns a stochastic policy that captures the intricacies of the action space. This enables better exploration during training and eventually better robustness to environmental perturbations at test time, i.e., the agent learns multimodal action space distributions which enables picking the next best action in case a perturbation prevents the execution of the optimal one. To achieve this, MaxEnt RL models the policy using the expressive family of EBMs (LeCun et al., 2006). This translates into learning policies that maximize the sum of expected future reward and expected future entropy. However, estimating the entropy of such complex distributions remains an open problem. To address this, existing approaches either use tricks to go around the entropy computation or make limiting assumptions on the policy. This results in either poor scalability or convergence to suboptimal solutions. For example, SQL (Haarnoja et al., 2017) implicitly incorporates entropy in the Q-function computation. This requires using importance sampling, which results in high variability and hence poor training stability and limited scalability to high dimensional action spaces. SAC (Haarnoja 1 arXiv:2405.00987v1  [cs.LG]  2 May 2024 \fPublished as a conference paper at ICLR 2024 \u03c0(\"|$!) \u03c0(\"|$\") STAC SQL SAC !! !\" S!AC Figure 2: S2AC learns a more optimal solution to the MaxEnt RL objective than SAC and SQL. We design a multigoal environment where an agent starts from the center of the 2-d map and tries to reach one of the three goals (G1, G2, and G3). The maximum expected future reward (level curves) is the same for all the goals but the expected future entropy is different (higher on the path to G2/G3): the action distribution \u03c0(a|s) is bi-modal on the path to the left (G2 and G3) and unimodal to the right (G1). Hence, we expect the optimal policy for the MaxEnt RL objective to assign more weights to G2 and G3. We visualize trajectories (in blue) sampled from the policies learned using SAC, SQL, and S2AC. SAC quickly commits to a single mode due to its actor being tied to a Gaussian policy. Though SQL also recovers the three modes, the trajectories are evenly distributed. S2AC recovers all the modes and approaches the left two goals more frequently. This indicates that it successfully maximizes not only the expected future reward but also the expected future entropy. et al., 2018a), on the other hand, follows a variational inference procedure by fitting a Gaussian distribution to the EBM policy. This enables a closed-form evaluation of the entropy but results in a suboptimal solution. For instance, SAC fails in environments characterized by multimodal action distributions. Similar to SAC, IAPO (Marino et al., 2021) models the policy as a uni-modal Gaussian. Instead of optimizing a MaxEnt objective, it achieves multimodal policies by learning a collection of parameter estimates (mean, variance) through different initializations for different policies. To improve the expressiveness of SAC, SSPG (Cetin & Celiktutan, 2022) and SAC-NF (Mazoure et al., 2020) model the policy as a Markov chain with Gaussian transition probabilities and as a normalizing flow (Rezende & Mohamed, 2015), respectively. However, due to training stability issues, the reported results in Cetin & Celiktutan (2022) show that though both models learn multi-modal policies, they fail to maximize the expected future entropy in positive rewards setups. We propose a new algorithm, S2AC, that yields a more optimal solution to the MaxEnt RL objective. To achieve expressivity, S2AC models the policy as a Stein Variational Gradient Descent (SVGD) (Liu, 2017) sampler from an EBM over Q-values (target distribution). SVGD proceeds by first sampling a set of particles from an initial distribution, and then iteratively transforming these particles via a sequence of updates to fit the target distribution. To compute a closed-form estimate of the entropy of such policies, we use the change-of-variable formula for pdfs (Devore et al., 2012). We prove that this is only possible due to the invertibility of the SVGD update rule, which does not necessarily hold for other popular samplers (e.g., Langevin Dynamics (Welling & Teh, 2011)). While normalizing flow models (Rezende & Mohamed, 2015) are also invertible, SVGD-based policy is more expressive as it encodes the inductive bias about the unnormalized density and incorporates a dispersion term to encourage multi-modality, whereas normalizing flows encode a restrictive class of invertible transformations (with easy-to-estimate Jacobian determinants). Moreover, our formula is computationally efficient and only requires evaluating first-order derivatives and vector products. To improve scalability, we model the initial distribution of the SVGD sampler as an isotropic Gaussian and learn its parameters, i.e., mean and standard deviation, end-to-end. We show that this results in faster convergence to the target distribution, i.e., fewer SVGD steps. Intuitively, the initial distribution learns to contour the high-density region of the target distribution while the SVGD updates result in better and faster convergence to the modes within that region. Hence, our approach is as parameter efficient as SAC, since the SVGD updates do not introduce additional trainable parameters. Note that S2AC can be reduced to SAC when the number of SVGD steps is zero. Also, SQL becomes equivalent to S2AC if the entropy is computed explicitly using our formula (the policy in SQL is an amortized SVGD sampler). Beyond RL, the backbone of S2AC is a new variational inference algorithm with a more expressive and scalable distribution characterized by a closed-form entropy estimate. We believe that this variational distribution can have a wider range of exciting applications. We conduct extensive empirical evaluations of S2AC from three aspects. We start with a sanity check on the merit of our derived SVGD-based entropy estimate on target distributions with known entropy values (e.g., Gaussian) or log-likelihoods (e.g., Gaussian Mixture Models) and assess its 2 \fPublished as a conference paper at ICLR 2024 sensitivity to different SVGD parameters (kernel, initial distribution, number of steps and number of particles). We observe that its performance depends on the choice of the kernel and is robust to variations of the remaining parameters. In particular, we find out that the kernel should be chosen to guarantee inter-dependencies between the particles, which turns out to be essential for invertibility. Next, we assess the performance of S2AC on a multi-goal environment (Haarnoja et al., 2017) where different goals are associated with the same positive (maximum) expected future reward but different (maximum) expected future entropy. We show that S2AC learns multimodal policies and effectively maximizes the entropy, leading to better robustness to obstacles placed at test time. Finally, we test S2AC on the MuJoCo benchmark (Duan et al., 2016). S2AC yields better performances than the baselines on four out of the five environments. Moreover, S2AC shows higher sample efficiency as it tends to converge with fewer training steps. These results were obtained from running SVGD for only three steps, which results in a small overhead compared to SAC during training. Furthermore, to maximize the run-time efficiency during testing, we train an amortized SVGD version of the policy to mimic the SVGD-based policy. Hence, this reduces inference to a forward pass through the policy network without compromising the performance. 2 PRELIMINARIES 2.1 SAMPLERS FOR ENERGY-BASED MODELS In this work, we study three representative methods for sampling from EBMs: (1) Stochastic Gradient Langevin Dynamics (SGLD) & Deterministic Langevin Dynamics (DLD) (Welling & Teh, 2011), (2) Hamiltonian Monte Carlo (HMC) (Neal et al., 2011), and (3) Stein Variational Gradient Descent (SVGD) (Liu & Wang, 2016). We review SVGD here since it is the sampler we eventually use in S2AC, and leave the rest to Appendix C.1. SVGD is a particle-based Bayesian inference algorithm. Compared to SGLD and HMC which have a single particle in their dynamics, SVGD operates on a set of particles. Specifically, SVGD samples a set of m particles {aj}m j=1 from an initial distribution q0 which it then transforms through a sequence of updates to fit the target distribution. Formally, at every iteration l, SVGD applies a form of functional gradient descent \u2206f that minimizes the KL-divergence between the target distribution p and the proposal distribution ql induced by the particles, i.e., the update rule for the ith particles is: al+1 i = al i + \u03f5\u2206f(al i) with \u2206f(al i) = Eal j\u223cql \u0002 k(al i, al j)\u2207al j log p(al j) + \u2207al jk(al i, al j) \u0003 . (1) Here, \u03f5 is the step size and k(\u00b7, \u00b7) is the kernel function, e.g., the RBF kernel: k(ai, aj) = exp(||ai \u2212 aj||2/2\u03c32). The first term within the gradient drives the particles toward the high probability regions of p, while the second term serves as a repulsive force to encourage dispersion. 2.2 MAXIMUM-ENTROPY RL We consider an infinite horizon Markov Decision Process (MDP) defined by a tuple (S, A, p, r), where S is the state space, A is the action space and p : S \u00d7 A \u00d7 S \u2192[0, \u221e] is the state transition probability modeling the density of the next state st+1 \u2208S given the current state st \u2208S and action at \u2208A. Additionally, we assume that the environment emits a bounded reward function r \u2208[rmin, rmax] at every iteration. We use \u03c1\u03c0(st) and \u03c1\u03c0(st, at) to denote the state and state-action marginals of the trajectory distribution induced by a policy \u03c0(at|st). We consider the setup of continuous action spaces Lazaric et al. (2007); Lee et al. (2018); Zhou & Lu (2023). MaxEnt RL (Todorov, 2006; Ziebart, 2010; Rawlik et al., 2012) learns a policy \u03c0\u2217(at|st), that instead of maximizing the expected future reward, maximizes the sum of the expected future reward and entropy: \u03c0\u2217= arg max\u03c0 X t \u03b3tE(st,at)\u223c\u03c1\u03c0 \u0002 r(st, at) + \u03b1H(\u03c0(\u00b7|st)) \u0003 , (2) where \u03b1 is a temperature parameter controlling the stochasticity of the policy and H(\u03c0(\u00b7|st)) is the entropy of the policy at state st. The conventional RL objective can be recovered for \u03b1 = 0. Note that the MaxEnt RL objective above is equivalent to approximating the policy, modeled as an EBM over Q-values, by a variational distribution \u03c0(at|st) (see proof of equivalence in Appendix D), i.e., \u03c0\u2217= arg min\u03c0 X t Est\u223c\u03c1\u03c0 \u0002 DKL \u0000\u03c0(\u00b7|st)\u2225exp(Q(st, \u00b7)/\u03b1)/Z \u0001\u0003 , (3) where DKL is the KL-divergence and Z is the normalizing constant. We now review two landmark MaxEnt RL algorithms: SAC (Haarnoja et al., 2018a) and SQL (Haarnoja et al., 2017). SAC is an actor-critic algorithm that alternates between policy evaluation, i.e., evaluating the Q-values for a policy \u03c0\u03b8(at|st): Q\u03d5(st, at) \u2190r(st, at) + \u03b3 Est+1,at+1\u223c\u03c1\u03c0\u03b8 \u0002 Q\u03d5(st+1, at+1) + \u03b1H(\u03c0\u03b8(\u00b7|st+1)) \u0003 (4) 3 \fPublished as a conference paper at ICLR 2024 and policy improvement, i.e., using the updated Q-values to compute a better policy: \u03c0\u03b8 = arg max\u03b8 X t Est,at\u223c\u03c1\u03c0\u03b8 \u0002 Q\u03d5(at, st) + \u03b1H(\u03c0\u03b8(\u00b7|st)) \u0003 . (5) SAC models \u03c0\u03b8 as an isotropic Gaussian, i.e., \u03c0\u03b8(\u00b7|s) = N(\u00b5\u03b8, \u03c3\u03b8I). While this enables computing a closed-form expression of the entropy, it incurs an over-simplification of the true action distribution, and thus cannot represent complex distributions, e.g., multimodal distributions. SQL goes around the entropy computation, by defining a soft version of the value function V\u03d5 = \u03b1 log \u0000 R A exp \u0000 1 \u03b1Q\u03d5(st, a\u2032) \u0001 da\u2032\u0001 . This enables expressing the Q-value (Eq (4)) independently from the entropy, i.e., Q\u03d5(st, at) = r(st, at) + \u03b3Est+1\u223cp[V\u03d5(st+1)]. Hence, SQL follows a soft value iteration which alternates between the updates of the \u201csoft\u201d versions of Q and value functions: Q\u03d5(st, at) \u2190r(st, at) + \u03b3Est+1\u223cp[V\u03d5(st+1)], \u2200(st, at) (6) V\u03d5(st) \u2190\u03b1 log \u0000 R A exp \u0000 1 \u03b1Q\u03d5(st, a\u2032) \u0001 da\u2032\u0001 , \u2200st. (7) Once the Q\u03d5 and V\u03d5 functions converge, SQL uses amortized SVGD Wang & Liu (2016) to learn a stochastic sampling network f\u03b8(\u03be, st) that maps noise samples \u03be into the action samples from the EBM policy distribution \u03c0\u2217(at|st) = exp \u0000 1 \u03b1(Q\u2217(st, at) \u2212V \u2217(st)) \u0001 . The parameters \u03b8 are obtained by minimizing the loss J\u03b8(st) = DKL \u0000\u03c0\u03b8(\u00b7|st)|| exp \u0000 1 \u03b1(Q\u2217 \u03d5(st, \u00b7) \u2212V \u2217 \u03d5 (st)) \u0001 with respect to \u03b8. Here, \u03c0\u03b8 denotes the policy induced by f\u03b8. SVGD is designed to minimize such KL-divergence without explicitly computing \u03c0\u03b8. In particular, SVGD provides the most greedy direction as a functional \u2206f\u03b8(\u00b7, st) (Eq (1)) which can be used to approximate the gradient \u2202J\u03b8/\u2202at. Hence, the gradient of the loss J\u03b8 with respect to \u03b8 is: \u2202J\u03b8(st)/\u2202\u03b8 \u221dE\u03be \u0002 \u2206f\u03b8(\u03be, st)\u2202f\u03b8(\u03be, st)/\u2202\u03b8 \u0003 . Note that the integral in Eq (7) is approximated via importance sampling, which is known to result in high variance estimates and hence poor scalability to high dimensional action spaces. Moreover, amortized generation is usually unstable and prone to mode collapse, an issue similar to GANs. Therefore, SQL is outperformed by SAC Haarnoja et al. (2018a) on benchmark tasks like MuJoCo. 3 APPROACH We introduce S2AC, a new actor-critic MaxEnt RL algorithm that uses SVGD as the underlying actor to generate action samples from policies represented using EBMs. This choice is motivated by the expressivity of distributions that can be fitted via SVGD. Additionally, we show that we can derive a closed-form entropy estimate of the SVGD-induced distribution, thanks to the invertibility of the update rule, which does not necessarily hold for other EBM samplers. Besides, we propose a parameterized version of SVGD to enable scalability to high-dimensional action spaces and nonsmooth Q-function landscapes. S2AC is hence capable of learning a more optimal solution to the MaxEnt RL objective (Eq (2)) as illustrated in Figure 2. 3.1 STEIN SOFT ACTOR CRITIC Like SAC, S2AC performs soft policy iteration which alternates between policy evaluation and policy improvement. The difference is that we model the actor as a parameterized sampler from an EBM. Hence, the policy distribution corresponds to an expressive EBM as opposed to a Gaussian. Critic. The critic\u2019s parameters \u03d5 are obtained by minimizing the Bellman loss as traditionally: \u03d5\u2217= arg min\u03d5 E(st,at)\u223c\u03c1\u03c0\u03b8 \u0002 (Q\u03d5(st, at) \u2212\u02c6 y)2\u0003 , (8) with the target \u02c6 y = rt(st, at) + \u03b3E(st+1,at+1)\u223c\u03c1\u03c0 \u0002 Q \u00af \u03d5(st+1, at+1) + \u03b1H(\u03c0(\u00b7|st+1)) \u0003 . Here \u00af \u03d5 is an exponentially moving average of the value network weights (Mnih et al., 2015). Actor as an EBM sampler. The actor is modeled as a sampler from an EBM over the Q-values. To generate a set of valid actions, the actor first samples a set of particles {a0} from an initial distribution q0 (e.g., Gaussian). These particles are then updated over several iterations l \u2208[1, L], i.e., {al+1} \u2190{al} + \u03f5h({al}, s) following the sampler dynamics characterized by a transformation h (e.g., for SVGD, h = \u2206f in Eq (1)). If q0 is tractable and h is invertible, it\u2019s possible to compute a closed-form expression of the distribution of the particles at the lth iteration via the change of variable formula Devore et al. (2012): ql(al|s) = ql\u22121(al\u22121|s) \f \fdet(I + \u03f5\u2207alh(al, s)) \f \f\u22121 , \u2200l \u2208[1, L]. In this case, the policy is represented using the particle distribution at the final step L of the sampler dynamics, i.e., \u03c0(a|s) = qL(aL|s) and the entropy can be estimated by averaging log qL(aL|s) over a set of particles (Section 3.2). We study the invertibility of popular EBM samplers in Section 3.3. 4 \fPublished as a conference paper at ICLR 2024 \ud835\udc4e! ! \ud835\udc4e! \"! \ud835\udc5e!(\ud835\udc4e|\ud835\udc60) \ud835\udc4e! ! \ud835\udc4e! #! \ud835\udc5e!(\ud835\udc4e|\ud835\udc60) S!AC(\ud835\udf19, \ud835\udf03) S!AC(\ud835\udf19) Figure 3: S2AC(\u03d5, \u03b8) achieves faster convergence to the target distribution (in orange) than S2AC(\u03d5) by parameterizing the initial distribution N(\u00b5\u03b8, \u03c3\u03b8) of the SVGD sampler. Parameterized initialization. To reduce the number of steps required to converge to the target distribution (hence reducing computation cost), we further propose modeling the initial distribution as a parameterized isotropic Gaussian, i.e., a0 \u223cN(\u00b5\u03b8(s), \u03c3\u03b8(s)). The parameterization trick is then used to express a0 as a function of \u03b8. Intuitively, the actor would learn \u03b8 such that the initial distribution is close to the target distribution. Hence, fewer steps are required to converge, as illustrated in Figure 3. Note that if the number of steps L = 0, S2AC is reduced to SAC. Besides, to deal with the non-smooth nature of deep Q-function landscapes which might lead to particle divergence in the sampling process, we bound the particle updates to be within a few standard deviations (t) from the mean of the learned initial distribution, i.e., \u2212t\u03c3\u03b8 \u2264al \u03b8 \u2264t\u03c3\u03b8, \u2200l \u2208[1, L]. Eventually, the initial distribution q0 \u03b8 learns to contour the high-density region of the target distribution and the following updates refine it by converging to the spanned modes. Formally, the parameters \u03b8 are computed by minimizing the expected KL-divergence between the policy qL \u03b8 induced by the particles from the sampler and the EBM of the Q-values: \u03b8\u2217=arg max\u03b8Est\u223cD,aL \u03b8 \u223c\u03c0\u03b8 \u0002 Q\u03d5(st, aL \u03b8 ) \u0003 + \u03b1Est\u223cD [H(\u03c0\u03b8(\u00b7|st))] s.t. \u2212t\u03c3\u03b8 \u2264al \u03b8 \u2264t\u03c3\u03b8, \u2200l \u2208[1, L]. (9) Here, D is the replay buffer. The derivation is in Appendix E. Note that the constraint does not truncate the particles as it is not an invertible transformation which then violates the assumptions of the change of variable formula. Instead, we sample more particles than we need and select the ones that stay within the range. We call S2AC(\u03d5, \u03b8) and S2AC(\u03d5) as two versions of S2AC with/without the parameterized initial distribution. The complete S2AC algorithm is in Algorithm 1 of Appendix A. 3.2 A CLOSED-FORM EXPRESSION OF THE POLICY\u2019S ENTROPY A critical challenge in MaxEnt RL is how to efficiently compute the entropy term H(\u03c0(\u00b7|st+1)) in Eq (2). We show that, if we model the policy as an iterative sampler from the EBM, under certain conditions, we can derive a closed-form estimate of the entropy at convergence. Theorem 3.1. Let F : Rn \u2192Rn be an invertible transformation of the form F(a) = a + \u03f5h(a). We denote by qL(aL) the distribution obtained from repeatedly applying F to a set of samples {a0} from an initial distribution q0(a0) over L steps, i.e., aL = F \u25e6F \u25e6\u00b7 \u00b7 \u00b7 \u25e6F(a0). Under the condition \u03f5||\u2207al ih(ai)||\u221e\u226a1, \u2200l \u2208[1, L], the distribution of the particles at the Lth step is: log qL(aL) \u2248log q0(a0) \u2212\u03f5 XL\u22121 l=0 Tr(\u2207alh(al)) + O(\u03f52dL). (10) Here, d is the dimensionality of a, i.e., a \u2208Rd and O(\u03f52dL) is the order of approximation error. Proof Sketch: As F is invertible, we apply the change of variable formula (Appendix C.2) on the transformation F \u25e6F \u25e6\u00b7 \u00b7 \u00b7 F and obtain: log qL(aL) = log q0(a0)\u2212PL\u22121 l=0 log \f \fdet(I + \u03f5\u2207alh(al)) \f \f. Under the assumption \u03f5||\u2207aih(ai)||\u221e\u226a1, we apply the corollary of Jacobi\u2019s formula (Appendix C.3) and get Eq. (10). The detailed proof is in Appendix F. Note that the condition \u03f5||\u2207aih(ai)||\u221e\u226a1 can always be satisfied when we choose a sufficiently small step size \u03f5, or the gradient of h(a) is small, i.e., h(a) is Lipschitz continuous with a sufficiently small constant. It follows from the theorem above, that the entropy of a policy modeled as an EBM sampler (Eq (9)) can be expressed analytically as: H(\u03c0\u03b8(\u00b7|s))=\u2212Ea0 \u03b8\u223cq0 \u03b8 h log qL \u03b8 (aL \u03b8 |s) i \u2248\u2212Ea0 \u03b8\u223cq0 \u03b8 h log q0 \u03b8(a0|s)\u2212\u03f5 XL\u22121 l=0 Tr \u0010 \u2207al \u03b8h(al \u03b8, s) \u0011 i . (11) In the following, we drop the dependency of the action on \u03b8 for simplicity of the notation. 3.3 INVERTIBLE POLICIES Next, we study the invertibility of three popular EBM samplers: SVGD, SGLD, and HMC as well as the efficiency of computing the trace, i.e., Tr(\u2207alh(al, s)) in Eq (10) for the ones that are invertible. Proposition 3.2 (SVGD invertibility). Given the SVGD learning rate \u03f5 and RBF kernel k(\u00b7, \u00b7) with variance \u03c3, if \u03f5 \u226a\u03c3, the update rule of SVGD dynamics defined in Eq (1) is invertible. 5 \fPublished as a conference paper at ICLR 2024 SVGD \u210b(\ud835\udc5e!) = 3.5 DLD \u210b(\ud835\udc5e!) = \u221225.93 SGLD \u210b(\ud835\udc5e!) = \u221211.57 HMC \u210b(\ud835\udc5e!) = \u221254.5 Initial Distribution \ud835\udc5e\" = \ud835\udca9(0, 6\ud835\udc3c) (a) Recovering the GT entropy m \u210b(\ud835\udc5e!) Kernel variance \ud835\udf0e (b) Effect of \u03c3 on H(qL) (\ud835\udc5a, \ud835\udc3f)= (\ud835\udc5a, \ud835\udc3f)= (\ud835\udc5a, \ud835\udc3f)= (\ud835\udc5a, \ud835\udc3f)= \u210b(\ud835\udc5e!) Target Distribution (c) Effect of m and L on H(qL) Figure 4: Entropy evaluation results. Proof Sketch: We use the explicit function theorem to show that the Jacobian \u2207aF(a, s) of the update rule F(a, s) is diagonally dominated and hence invertible. This yields invertibility of F(a, s). See detailed proof in Appendix G.3. Theorem 3.3. The closed-form estimate of log qL(aL|s) for the SVGD based sampler with an RBF kernel k(\u00b7, \u00b7) is log qL(aL|s)\u2248logq0(a0|s)+ \u03f5 m\u03c32 L\u22121 X l=0 m X j=1,al\u0338=al j k(al j, al) \u0010 (al\u2212al j)\u22a4\u2207al jQ(s, al j)+ \u03b1 \u03c32 \u2225al\u2212al j\u22252\u2212d\u03b1 \u0011 . Here, (\u00b7)\u22a4denotes the transpose of a matrix/vector. Note that the entropy does not depend on any matrix computation, but only on vector dot products and first-order vector derivatives. The proof is in Appendix H.1. Intuitively, the derived likelihood is proportional to (1) the concavity of the curvature of the Q-landscape, captured by a weighted average of the neighboring particles\u2019 Q-value gradients and (2) pairwise-distances between the neighboring particles (\u223c\u2225al i\u2212al j\u22252 \u00b7 exp (\u2225al i\u2212al j\u22252)), i.e., the larger the distance the higher is the entropy. We elaborate on the connection between this formula and non-parametric entropy estimators in Appendix B. Proposition 3.4 (SGLD, HMC). The SGLD and HMC updates are not invertible w.r.t. a. Proof Sketch: SGLD is stochastic (noise term) and thus not injective. HMC is only invertible if conditioned on the velocity v. Detailed proofs are in Appendices G.1-G.2. From the above theoretic analysis, we can see that SGLD update is not invertible and hence is not suitable as a sampler for S2AC. While the HMC update is invertible, its derived closed-form entropy involves calculating Hessian and hence computationally more expensive. Due to these considerations, we choose to use SVGD with an RBF kernel as the underlying sampler of S2AC. 4 RESULTS We first evaluate the correctness of our proposed closed-form entropy formula. Then we present the results of different RL algorithms on multigoal and MuJoCo environments. 4.1 ENTROPY EVALUATION This experiment tests the correctness of our entropy formula. We compare the estimated entropy for distributions (with known ground truth entropy or log-likelihoods) using different samplers and study the sensitivity of the formula to different samplers\u2019 parameters. (1) Recovering the ground truth entropy. In Figure 4a, we plot samples (black dots) obtained by SVGD, SGLD, DLD and HMC at convergence to a Gaussian with ground truth entropy H(p) = 3.41, starting from the same initial distribution (leftmost sub-figure). We also report the entropy values computed via Eq.(11). Unlike SGLD, DLD, and HMC, SVGD recovers the ground truth entropy. This empirically supports Proposition 3.4 that SGLD, DLD, and HMC are not invertible. (2) Effect of the kernel variance. Figure 4b shows the effect of different SVGD kernel variances \u03c3, where we use the same initial Gaussian from Figure 4a. We also visualize the particle distributions after L SVGD steps for the different configurations in Figure 9 of Appendix I. We can see that when the kernel variance is too small (e.g., \u03c3 = 0.1), the invertibility is violated, and thus the estimated entropy is wrong even at convergence. On the other extreme when the kernel variance is too large (e.g., \u03c3=100), i.e., when the particles are too scattered initially, the particles do not converge to the target Gaussian due to noisy gradients in the first term of Eq.(1). The best configurations hence lie somewhere in between (e.g., \u03c3\u2208{3, 5, 7}). (3) Effect of SVGD steps and particles. Figure 4c and Figure 10b (Appendix. I) show the behavior of our entropy formula under different configurations of the number of SVGD steps and particles, on two settings: (i) GMM M with an increasing number of components M, and (ii) distributions with increasing ground truth entropy values, i.e., Gaussians with increasing variances \u03c3. Results show that our entropy consistently grows with an increasing M (Figure 4c) and increasing \u03c3 (Figure 10b), even when a small number of SVGD steps and particles is used (e.g., L = 10, m = 10). 6 \fPublished as a conference paper at ICLR 2024 4.2 MULTI-GOAL EXPERIMENTS ! = 0.2 ! = 1 ! = 10 ! = 20 '! '\" (', (( () Multigoal Environment Figure 5: Multigoal env. To check if S2AC learns a better solution to the max-entropy objective (Eq (2)), we design a new multi-goal environment as shown in Figure 5. The agent is a 2D point mass at the origin trying to reach one of the goals (in red). Q-landscapes are depicted by level curves. Actions are bounded in [\u22121, 1] along both axes. Critical states for the analysis are marked with blue crosses. It is built on the multi-goal environment in Haarnoja et al. (2017) with modifications such that all the goals have (i) the same maximum expected future reward (positive) but (ii) different maximum expected future entropy. This is achieved by asymmetrically placing the goals (two goals on the left side and one on the right, leading to a higher expected future entropy on the left side) while assigning the same final rewards to all the goals. The problem setup and hyperparameters are detailed in Appendix J. (1) Multi-modality. Figure 6 visualizes trajectories (blue lines) collected from 20 episodes of S2AC(\u03d5, \u03b8), S2AC(\u03d5), SAC, SQL and SAC-NF (SAC with a normalizing flow policy, Mazoure et al. (2020)) agents (rows) at test time for increasing entropy weights \u03b1 (columns). S2AC and SQL consistently cover all the modes for all \u03b1 values, while this is only achieved by SAC and SAC-NF for large \u03b1 values. Note that, in the case of SAC, this comes at the expense of accuracy. Although normalizing flows are expressive enough in theory, they are known to quickly collapse to local optima in practice Kobyzev et al. (2020). The dispersion term in S2AC encodes an inductive bias to mitigate this issue. (2) Maximizing the expected future entropy. We also see that with increasing \u03b1, more S2AC and SAC-NF trajectories converge to the left goals (G2/G3). This shows both models learn to maximize the expected future entropy. This is not the case for SQL whose trajectory distribution remains uniform across the goals. SAC results do not show a consistent trend. This validates the hypothesis that the entropy term in SAC only helps exploration but does not lead to maximizing future entropy. The quantified distribution over reached goals is in Figure 12 of Appendix J. (3) Robustness/adaptability. To assess the robustness of the learned policies, we place an obstacle (red bar in Figure 7) on the path to G2. We show the test time trajectories of 20 episodes using S2AC, SAC, SQL and SAC-NF agents trained with different \u03b1\u2019s. We observe that, for S2AC and SAC-NF, with increasing \u03b1, more trajectories reach the goal after hitting the obstacles. This is not the case for SAC, where many trajectories hit the obstacle without reaching the goal. SQL does not manage to escape the barrier even with higher \u03b1. Additional results on the (4) effect of parameterization of q0, and the (5) entropy\u2019s effect on the learned Q-landscapes are respectively reported in Figure 11 and Figure 14 of Appendix J. S!AC(\ud835\udf19) SAC SQL S!AC(\ud835\udf19, \ud835\udf03) \ud835\udefc= 0.2 \ud835\udefc= 1 \ud835\udefc= 10 \ud835\udefc= 20 SAC-NF Figure 6: S2AC and SAC-NF learn to maximize the expected future entropy (biased towards G2/G3) while SAC and SQL do not. S2AC consistently recovers all modes, while SAC-NF with smaller \u03b1\u2019s does not, indicating its instability. S!AC(\ud835\udf19) SAC SQL S!AC(\ud835\udf19, \ud835\udf03) \ud835\udefc= 0.2 \ud835\udefc= 1 \ud835\udefc= 10 \ud835\udefc= 20 SAC-NF Figure 7: S2AC and SAC-NF are more robust to perturbations. Obstacle O is placed diagonally at [\u22121, 1]. Trajectories that did and did not reach the goal after hitting O are in green and red, respectively. 7 \fPublished as a conference paper at ICLR 2024 0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 Steps \u00a3105 0 500 1000 1500 2000 2500 3000 3500 Average Return 0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 Steps \u00a3105 \u00b0500 0 500 1000 1500 2000 2500 3000 Average Return 0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 Steps \u00a3105 0 2000 4000 6000 8000 Average Return 0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 Steps \u00a3105 0 500 1000 1500 2000 2500 3000 3500 4000 Average Return PPO SAC-NF DDPG SAC S2AC(\u00a1, \u00b5, \u221a) S2AC(\u00a1, \u00b5) S2AC(\u00a1) SQL 0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 Steps \u00a3105 0 500 1000 1500 2000 2500 3000 3500 4000 Average Return (a) Hopper-v2 (b) Walker2d-v2 (c) HalfCheetah-v2 (d) Ant-v2 (e) Humanoid-v2 (f) Median (g) IQM (h) Mean (i) Optimality Gap (j) P(X>Y) Figure 8: (a)-(e): Performance curves on the MuJoCo benchmark (training). S2AC outperforms SQL and SAC-NF on all environments and SAC on 4 out of 5 environments. (f)-(i): Comparison of Median, IQM, Mean, and Optimality Gap between S2AC and baseline algorithms. (j): The probabilities of S2AC outperforming baseline algorithms. 4.3 MUJOCO EXPERIMENTS We evaluate S2AC on five environments from MuJoCo (Brockman et al., 2016): Hopper-v2, Walker2dv2, HalfCheetah-v2, Ant-v2, and Humanoid-v2. As baselines, we use (1) DDPG (Gu et al., 2017), (2) PPO (Schulman et al., 2015), (3) SQL (Haarnoja et al., 2017), (4) SAC-NF (Mazoure et al., 2020), and (5) SAC (Haarnoja et al., 2018a). Hyperparameters are in Appendix K. (1) Performance and sample efficiency. We train five different instances of each algorithm with different random seeds, with each performing 100 evaluation rollouts every 1000 environment steps. Performance results are in Figure 8(a)-(e). The solid curves correspond to the mean returns over the five trials and the shaded region represents the minimum and maximum. S2AC(\u03d5, \u03b8) is consistently better than SQL and SAC-NF across all the environments and has superior performance than SAC in four out of five environments. Results also show that the initial parameterization was key to ensuring the scalability (S2AC(\u03d5) has poor performance compared to S2AC(\u03d5, \u03b8)). Figure 8(f)-(j) demonstrate the statistical significance of these gains by leveraging statistics from the rliable library (Agarwal et al., 2021) which we detail in Appendix K. Hopper Walker2d HalfCheetah Ant Action dim 3 6 6 8 State dim 11 17 17 111 SAC 0.723 0.714 0.731 0.708 SQL 0.839 0.828 0.815 0.836 S2AC(\u03d5, \u03b8) 3.267 4.622 4.583 5.917 S2AC(\u03d5, \u03b8, \u03c8) 0.850 0.817 0.830 0.837 Table 1: Action selection run-time on MuJoCo. (2) Run-time. We report the run-time of action selection of SAC, SQL, and S2AC algorithms in Table 1. S2AC(\u03d5, \u03b8) run-time increases linearly with the action space. To improve the scalability, we train an amortized version that we deploy at test-time, following (Haarnoja et al., 2017). Specifically, we train a feed-forward deepnet f\u03c8(s, z) to mimic the SVGD dynamics during testing, where z is a random vector that allows mapping the same state to different particles. Note that we cannot use f\u03c8(s, z) during training as we need to estimate the entropy in Eq (11), which depends on the unrolled SVGD dynamics (details in Appendix K). The amortized version S2AC(\u03d5, \u03b8, \u03c8) has a similar run-time to SAC and SQL with a slight tradeoff in performance (Figure 8). 5 RELATED WORK MaxEnt RL (Todorov, 2006; Ziebart, 2010; Rawlik et al., 2012) aims to learn a policy that gets high rewards while acting as randomly as possible. To achieve this, it maximizes the sum of expected future reward and expected future entropy. It is different from entropy regularization (Schulman et al., 2015; O\u2019Donoghue et al., 2016; Schulman et al., 2017) which maximizes entropy at the current time step. It is also different from multi-modal RL approaches (Tang & Agrawal, 2018) which recover different modes with equal frequencies without considering their future entropy. MaxEnt RL has been broadly incorporated in various RL domains, including inverse RL (Ziebart et al., 2008; Finn et al., 2016), stochastic control (Rawlik et al., 2012; Toussaint, 2009), guided policy search (Levine & Koltun, 2013), and off-policy learning (Haarnoja et al., 2018a;b). MaxEnt RL is shown to maximize a lower bound of the robust RL objective (Eysenbach & Levine, 2022) and is hence less sensitive 8 \fPublished as a conference paper at ICLR 2024 to perturbations in state and reward functions. From the variational inference lens, MaxEnt RL aims to find the policy distribution that minimizes the KL-divergence to an EBM over Q-function. The desired family of variational distributions is (1) expressive enough to capture the intricacies of the Q-value landscape (e.g., multimodality) and (2) has a tractable entropy estimate. These two requirements are hard to satisfy. SAC (Haarnoja et al., 2018a) uses a Gaussian policy. Despite having a tractable entropy, it fails to capture arbitrary Q-value landscapes. SAC-GMM (Haarnoja, 2018) extends SAC by modeling the policy as a Gaussian Mixture Model, but it requires an impractical grid search over the number of components. Other extensions include IAPO (Marino et al., 2021) which also models the policy as a uni-modal Gaussian but learns a collection of parameter estimates (mean, variance) through different initializations. While this yields multi-modality, it does not optimize a MaxEnt objective. SSPG (Cetin & Celiktutan, 2022) and SAC-NF (Mazoure et al., 2020) respectively improve the policy expressivity by modeling the policy as a Markov chain with Gaussian transition probabilities and as a normalizing flow. Due to training instability, the reported multi-goal experiments in (Cetin & Celiktutan, 2022) show that, though both models capture multimodality, they fail to maximize the expected future entropy in positive reward setups. SQL (Haarnoja et al., 2017), on the other hand, bypasses the explicit entropy computation altogether via a soft version of value iteration. It then trains an amortized SVGD (Wang & Liu, 2016) sampler from the EBM over the learned Q-values. However, estimating soft value functions requires approximating integrals via importance sampling which is known to have high variance and poor scalability. We propose a new family of variational distributions induced by a parameterized SVGD sampler from the EBM over Q-values. Our policy is expressive and captures multi-modal distributions while being characterized by a tractable entropy estimate. EBMs (LeCun et al., 2006; Wu et al., 2018) are represented as Gibbs densities p(x) = exp E(x)/Z, where E(x) \u2208R is an energy function describing inter-variable dependencies and Z = R exp E(x) is the partition function. Despite their expressiveness, EBMs are not tractable as the partition function requires integrating over an exponential number of configurations. Markov Chain Monte Carlo (MCMC) methods (Van Ravenzwaaij et al., 2018) (e.g., HMC (Hoffman & Gelman, 2014), SGLD (Welling & Teh, 2011)) are frequently used to approximate the partition function via sampling. There have been recent efforts to parameterize these samplers via deepnets (Levy et al., 2017; Gong et al., 2018; Feng et al., 2017) to improve scalability. Similarly to these methods, we propose a parameterized variant of SVGD (Liu & Wang, 2016) as an EBM sampler to enable scalability to highdimensional action spaces. Beyond sampling, we derive a closed-form expression of the sampling distribution as an estimate of the EBM. This yields a tractable estimate of the entropy. This is opposed to previous methods for estimating EBM entropy which mostly rely on heuristic approximation, lower bounds Dai et al. (2017; 2019a), or neural estimators of mutual information (Kumar et al., 2019). The idea of approximating the entropy of EBMs via MCMC sampling by leveraging the change of variable formula was first proposed in Dai et al. (2019b). The authors apply the formula to HMC and LD, which, as we show previously, violate the invertibility assumption. To go around this, they augment the EBM family with the noise or velocity variable for LD and HMC respectively. But the derived log-likelihood of the sampling distribution turns out to be \u2013counter-intuitively\u2013 independent of the sampler\u2019s dynamics and equal to the initial distribution, which is then parameterized using a flow model (details in Appendix B.2). We show that SVGD is invertible, and hence we sample from the original EBM, so that our derived entropy is more intuitive as it depends on the SVGD dynamics. SVGD-augmented RL (Liu & Wang, 2016) has been explored under other RL contexts. Liu et al. (2017) use SVGD to learn a distribution over policy parameters. While this leads to learning diverse policies, it is fundamentally different from our approach as we are interested in learning a single multi-modal policy with a closed-form entropy formula. Castanet et al. (2023); Chen et al. (2021) use SVGD to sample from multimodal distributions over goals/tasks. We go beyond sampling and use SVGD to derive a closed-form entropy formula of an expressive variational distribution. 6"
+                },
+                {
+                    "url": "http://arxiv.org/abs/2105.06441v1",
+                    "title": "DeepQAMVS: Query-Aware Hierarchical Pointer Networks for Multi-Video Summarization",
+                    "abstract": "The recent growth of web video sharing platforms has increased the demand for\nsystems that can efficiently browse, retrieve and summarize video content.\nQuery-aware multi-video summarization is a promising technique that caters to\nthis demand. In this work, we introduce a novel Query-Aware Hierarchical\nPointer Network for Multi-Video Summarization, termed DeepQAMVS, that jointly\noptimizes multiple criteria: (1) conciseness, (2) representativeness of\nimportant query-relevant events and (3) chronological soundness. We design a\nhierarchical attention model that factorizes over three distributions, each\ncollecting evidence from a different modality, followed by a pointer network\nthat selects frames to include in the summary. DeepQAMVS is trained with\nreinforcement learning, incorporating rewards that capture representativeness,\ndiversity, query-adaptability and temporal coherence. We achieve\nstate-of-the-art results on the MVS1K dataset, with inference time scaling\nlinearly with the number of input video frames.",
+                    "authors": "Safa Messaoud, Ismini Lourentzou, Assma Boughoula, Mona Zehni, Zhizhen Zhao, Chengxiang Zhai, Alexander G. Schwing",
+                    "published": "2021-05-13",
+                    "updated": "2021-05-13",
+                    "primary_cat": "cs.CV",
+                    "cats": [
+                        "cs.CV",
+                        "cs.AI",
+                        "cs.IR"
+                    ],
+                    "main_content": "INTRODUCTION From Snapchat and Youtube to Twitter, Facebook and ByteDance, video sharing has influenced social media significantly over the past years. Video views increased over 99% on YouTube and 258% on Facebook, in just a single year1. To date, more than 5 billion videos have been shared on Youtube, where users daily spend 1 billion hours watching the uploaded content2. Facebook also reached 100 million hours of video watching every day3. Given a query, current video search engines return hundreds of videos, often redundant and difficult for the user to comprehend without spending a significant amount of time and effort to find the information of interest. To effectively tackle this issue, Query-Aware Multi-Video Summarization (QAMVS) methods select a subset of frames from the retrieved videos and form a concise topic-related summary conditioned on the user search intent [22, 25]. A compelling summary should be (1) concise, (2) representative of the query-relevant events, and (3) chronologically sound. Naively applying traditional single video summarization (SVS) techniques 1https://www.wyzowl.com/video-social-media-2020/ 2https://www.omnicoreagency.com/youtube-statistics/ 3https://99firms.com/blog/facebook-video-statistics/ arXiv:2105.06441v1  [cs.CV]  13 May 2021 \fresults in suboptimal summaries, as SVS methods fail to capture all aforementioned criteria. Overall, QAMVS is more challenging than SVS. First, QAMVS needs to ensure temporal coherence, a non-trivial task since the frames are selected from multiple different videos. In contrast, for SVS the chronological order is given by the video frame order. Secondly, QAMVS methods need to filter large noisy content as videos contain a lot of query-irrelevant information. Hence, QAMVS involves modeling the interactions between two or more modalities, i.e., the set of videos and the query contents. In contrast, a clustering formulation optimizing for the summary diversity yields good results for SVS. Prior work relies on multi-stage pipelines to sequentially optimize for the aforementioned criteria. First, a set of candidate frames is selected following graph-based [7, 24, 28], decomposition-based [22, 25, 46] or learning-based [41, 65] methods. Next, the list of frames is refined to be query-adaptive by ignoring frames that are dissimilar to a set of web-images retrieved with the same query [22, 24, 25, 28]. Finally, the selected frames are ordered to form a coherent summary, either based on importance scores assigned at the video level [46, 65] or by topic-closeness [22, 24, 25]. Due to the sequential nature of these methods we observe significant shortcomings: (1) multi-stage procedures result in error propagation; (2) existing methods have polynomial complexity with respect to the size of the video set and the video lengths, and (3) the use of multi-modal meta-data is often limited to candidate frame selection instead of guiding the summarization in every step. To address these shortcomings, in this work, we propose a unified end-to-end trainable model for the QAMVS task. Our architecture (summarized in Figure 1) is a hierarchical attention-based sequenceto-sequence model which significantly reduces the computational complexity from polynomial to linear compared to the current state-of-the-art methods and alleviates error propagation due to being a unified approach. We achieve this via a pointer network, which selects the frames to include in the summary, thus removing the burden of rearranging the frames in a separate subsequent step. The attention of the pointer network factorizes over three distributions, each collecting evidence from a different modality, guiding the summarization process in every step. To address the challenge of limited ground truth supervision, we train our model using reinforcement learning, incorporating representativeness, diversity, query-adaptability and temporal coherence rewards. The key contributions of this work are summarized as follows: (1) We design a novel end-to-end Query-Aware Multi-Video Summarization (DeepQAMVS) framework that jointly optimizes multiple crucial criteria of this challenging task: (i) conciseness, (ii) chronological soundness and (iii) representativeness of all query-related events. (2) We adopt pointer networks to remove the burden of rearranging the selected frames towards forming a chronologically coherent summary and design a hierarchical attention mechanism that models the cross-modal semantic dependencies between the videos and the query, achieving state-of-the-art performance. (3) We employ reinforcement learning to avoid over-fitting to the limited ground-truth data. We introduce two novel rewards that capture query-adaptability and temporal coherence. We conduct extensive experiments on the challenging MVS1K dataset. Quantitative and qualitative analysis shows that our model achieves state-of-the-art results and generates visually coherent summaries. 2 RELATED WORK We cover related work on single video summarization (SVS), multivideo summarization (MVS) and pointer networks (PN). 2.1 Single Video Summarization Both supervised and unsupervised methods have been proposed for the SVS task. On the supervised side, methods involve categoryspecific classifiers for importance scoring of different video segments [51, 62], sequential determinantal point processes [16, 57, 58], LSTMs [37, 55, 71], encoder-decoder architectures [6, 23], memory networks [14] and semantic aware techniques which include video descriptors [67], vision-language embeddings [50, 63] and textsummarization metrics [69]. Instead, unsupervised methods rely on low-level visual features to determine the important parts of a video. Strategies include clustering [10, 17, 45], maximal bi-clique finding [7], energy minimization [52] and sparse-coding [8, 12, 13, 80]. Recently, convolutional models [54], generative adversarial networks [15, 39, 53, 75, 76] and reinforcement learning [29, 48, 74, 81] have shown compelling results on the SVS task. Using queries to guide the summary has been explored in SVS. Proposed methods condition the summary generation on the textual query embedding [74, 76], learn common textual-visual coembeddings for both the query and the frames [63], or enrich the visual features with textual ones obtained from dense textual shot annotations [58, 59]. As current multi-video datasets contain video-level titles/descriptions and abstract queries (e.g., retirement, wedding, terror attack), the aforementioned methods are not applicable. Instead, we use the query to retrieve a set of web-images that represent its major sub-concepts/sub-events and use these images to condition the summary generation process. Note that query-adaptability is more critical in the case of MVS due to large irrelevant content across different videos. In general, SVS methods that operate on a single long video obtained by concatenating all videos to be summarized, such as \ud835\udc58-means [10] and Dominant Set Clustering (DSC) [3], also result in lower performance than methods designed specifically for the QAMVS problem. These methods first form clusters of frames, select centroids as candidate frames and then compute diversity to eliminate similar keyframes before generating the final summary. Due to the lack of an ordering mechanism, SVS methods result in low consistency across selected frames that reduces readability and smoothness of the overall summary, affecting significantly the user viewing experience [11]. Nevertheless, to emphasize the importance of designing techniques that tackle QAMVS specifically, we also report results for SVS approaches in our evaluation. 2.2 Multi-Video Summarization Applications range from multi-view summarization aiming at summarizing videos captured for the same scene with several dynamically moving cameras (e.g., in surveillance) [21, 38, 43, 44, 82], and summarizing of user-devices\u2019 videos [1, 41, 72, 73, 77\u201379] (e.g., for cities hotspot preview [78] or city navigation [77]) to topicrelated MVS (QAMVS) [22, 25, 28, 41, 46, 66]. Early attempts to solve the QAMVS task applied techniques optimizing for diversity [9, 20, 26, 31\u201335, 46, 47, 65, 66]. However, methods that advocate for these metrics cannot solve the QAMVS task satisfactorily, as \f1 2 3 4 Frame Distribution LSTM LSTM LSTM ... LSTM Final Summary Hierarchical Attention Web Images   Text  Data 1. William and Kate leave Buckingham Palace 2. William and Kate kiss on the balcony 3. William and Kate walk down aisle Query: Prince William Wedding Videos' Titles & Descriptions Video 2 Video 3 Videos Video 1 Figure 2: Overview of the policy network. DeepQAMVS is modeled as a Pointer Network with Hierarchical Attention (Figure 3). The policy \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121,\ud835\udc5e, D, I) is constructed by gathering evidence from the videos, the query images and the textual data. During inference, the frame with the highest probability from the video collection is copied into the final summary Y \ud835\udc3f. (1) unimportant yet diverse frames are selected due to the high amount of irrelevant information across the different videos and (2) frames are not ordered chronologically to make a coherent story. Nevertheless, to emphasize the importance of designing techniques that tackle QAMVS challenges specifically, we also report results for diversity-oriented approaches in our evaluation. More recent QAMVS methods can be divided into three categories: (1) graphbased, (2) decomposition-based, and (3) learning-based. Graph-based methods construct a graph of relationships between frames of different videos, from which the most representative ones are selected. For example, Kim et al. [28] summarized query related videos by performing diversity ranking on top of the similarity graphs between query web-images and video frames, in order to reconstruct a storyline graph of query-relevant events. Ji et al. [24] proposed a clustering-based procedure using a hyper-graph dominant set, followed by a refinement step to filter frames that are most dissimilar to the query web-images, and a final step where the remaining candidates are ordered based on topic closeness. Decomposition-based approaches subsume weighted archetypal analysis and sparse-coding. Ji et al. [25] proposed a two-stage approach, where the frames are first extracted using multimodal Weighted Archetypal Analysis (MWAA). Here, the weights are obtained from a graph fusing information from video frames, textual meta-data and query-dependent web-images. Next, the frames are chronologically ordered based on upload time and topic-closeness. Panda et al. [46] formulated QAMVS as a sparse coding program regularized with interestingness and diversity metrics, followed by ordering the frames using a video-relevance score. While Panda et al. [46] did not account for query-adaptability, Ji et al. [22] extended the latter with an additional regularization term enforcing the selected frames to be similar to the query web-images. To form the final summary, frames are then ordered chronologically by grouping them into events based on textual and visual similarity. For learning-based methods, Wang et al. [66] proposed a multipleinstance learning approach to localize the tags into video shots and select the query-aware frames in accordance with the tags. Nie et al. [41] selected frames from semantically important regions and then use a probabilistic model to jointly optimize for multiple attributes such as aesthetics, coherence, and stability. In contrast to previous approaches that propose modularized solutions, we design a unified end-to-end model for QAMVS to generate visually coherent summaries in an end-to-end fashion. 2.3 Pointer Networks Pointer Networks (PNs) have been applied to solve combinatorial optimization problems, e.g., traveling-salesman [2] and language modeling tasks [64]. At every time step, the output is constructed by iteratively copying an input item that is chosen by the pointer. This property is uniquely convenient for the QAMVS task. Our model is the first to use a Pointer Network for QAMVS. PNs, unlike other Seq2Seq models (e.g., LSTM [71] or seqDPP [16]), enable attending to any frame in any video at any time point. Hence, they naturally generate an ordered sequence of frames, while the attention mechanism fuses the multi-modal information to select the next best frame satisfying diversity, query-relevance and visual coherence (Figure 3). We train the Pointer Network in our model using reinforcement learning, as it is useful for tasks with limited labeled data [4, 5, 19, 30, 36, 40, 56], as in the case of QAMVS. 3 PROPOSED DEEPQAMVS MODEL Given a collection of videos and images retrieved by searching with a common text query that encodes user preferences, the goal is to generate a topic-related summary for the videos. DeepQAMVS utilizes both web-images and textual meta-data. Web-images are particularly useful as they guide the summarization towards discarding irrelevant information (image attention). However, they \fVideo 1 Video 2 Video 3 Attention Operator Attention Operator Attention Operator Attention Operator Attention Operator Attention Operator Videos Text  Data 1. William and Kate leave Buckingham Palace 2. William and Kate kiss on the balcony 3. William and Kate walk down aisle Query: Prince William Wedding Videos' Titles & Descriptions Web Images   Figure 3: Illustration of DeepQAMVS\u2019s Hierarchical Attention \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121,\ud835\udc5e, D, I). might contain irrelevant information. To robustly ensure queryrelevance, DeepQAMVS leverages multi-modal attention which enables the web-images and textual meta-data (query attention) to act as complementary information that guides the summarization process. In the following, we first formally define the problem, then introduce the proposed DeepQAMVS model. 3.1 Problem Formulation Let \ud835\udc5ebe the semantic embedding of the textual query and let I = {\ud835\udc3c1, \u00b7 \u00b7 \u00b7 , \ud835\udc3c|I |} refer to the set of web-image embeddings. We denote by X(\ud835\udc63) = {\ud835\udc65(\ud835\udc63) 1 , \u00b7 \u00b7 \u00b7 ,\ud835\udc65(\ud835\udc63) |X(\ud835\udc63) |} the set of frame embeddings from video \ud835\udc63\u2208{1, \u00b7 \u00b7 \u00b7 , \ud835\udc41}. Let D = {\ud835\udc51(1), \u00b7 \u00b7 \u00b7 ,\ud835\udc51(\ud835\udc41)} be the text embeddings of the videos\u2019 textual data, constructed by averaging the embeddings of the title and description for every video. The goal is to generate a summary Y \ud835\udc3f= {\ud835\udc661, \u00b7 \u00b7 \u00b7 ,\ud835\udc66\ud835\udc3f} of \ud835\udc3fframes selected from the input video frames, i.e., Y \ud835\udc3f\u2282X = \u00d0 \ud835\udc63X(\ud835\udc63). Due to the sequential nature of the problem, i.e., selecting the next candidate frame based on what has been selected so far, we formulate the QAMVS problem as a Markov Decision Process (MDP). Specifically, an agent operates in \ud835\udc61\u2208{1, \u00b7 \u00b7 \u00b7 , \ud835\udc3f} time-steps according to a policy \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121,\ud835\udc5e, D, I) with trainable parameters \ud835\udf03. The policy encodes the probability of selecting an action \ud835\udc4e\ud835\udc61given the state Y \ud835\udc61\u22121, the query \ud835\udc5e, the text meta-data D and the webimages I. The state Y \ud835\udc61\u22121 denotes the set of frames that are already selected in the summary up to time step \ud835\udc61. Note that Y 0 = \u2205. The set of possible actions is the set of input frames after eliminating the ones that have already been selected in the summary, i.e., \ud835\udc4e\ud835\udc61\u2208A\ud835\udc61= X \\ Y \ud835\udc61\u22121. We denote by A(\ud835\udc63) \ud835\udc61 the set of valid actions corresponding to frames from video \ud835\udc63. We model the policy function \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121,\ud835\udc5e, D, I) as a pointer network with hierarchical attention, as illustrated in Figure 2. At inference step \ud835\udc61, the inputs (X, D and I), together with the state Y \ud835\udc61\u22121, are used to compute the distribution \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121,\ud835\udc5e, D, I) over possible actions \ud835\udc4e\ud835\udc61, i.e., over possible frames. The frame with the highest probability is then copied to the summary Y \ud835\udc61. The process continues until a summary of length \ud835\udc3fis reached. Next, we describe the policy \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121,\ud835\udc5e, D, I). 3.2 DeepQAMVS Policy Network Our proposed policy function models the cross-modal semantic dependencies between the videos, the text query and the webimages. More specifically, the policy network \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121,\ud835\udc5e, D, I) is the weighted combination of three distributions, video frame attention \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121), image attention \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121, I), and query attention \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121,\ud835\udc5e, D). Formally, \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121,\ud835\udc5e, D, I) = \ud835\udf07(1) \ud835\udc61 \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121)+ \ud835\udf07(2) \ud835\udc61 \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121, I) + \ud835\udf07(3) \ud835\udc61 \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121,\ud835\udc5e, D), (1) where \ud835\udf07(1) \ud835\udc61 , \ud835\udf07(2) \ud835\udc61 and \ud835\udf07(3) \ud835\udc61 are learnable interpolation terms satisfying \ud835\udf07(1) \ud835\udc61 + \ud835\udf07(2) \ud835\udc61 + \ud835\udf07(3) \ud835\udc61 = 1. An illustration of the hierarchical attention is provided in Figure 3. In the following, we introduce each of these three distributions. The video frame attention \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121) is modeled as a two-level attention, i.e., at each time step \ud835\udc61, video attention selects video \ud835\udc63 and then selects a frame \ud835\udc4e\ud835\udc61from video \ud835\udc63: \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121) = \ud835\udc41 \u2211\ufe01 \ud835\udc63=1 \ud835\udc5d(\ud835\udc63|Y \ud835\udc61\u22121)\ud835\udc5d(\ud835\udc4e\ud835\udc61|\ud835\udc63, Y \ud835\udc61\u22121), (2) where \ud835\udc5d(\ud835\udc4e\ud835\udc61|\ud835\udc63, Y \ud835\udc61\u22121) is the probability of selecting a frame \ud835\udc4e\ud835\udc61from video \ud835\udc63, and \ud835\udc5d(\ud835\udc63|Y \ud835\udc61\u22121) is the distribution over the collection of videos. We compute both probabilities via \ud835\udc5d(\ud835\udc4e\ud835\udc61|\ud835\udc63, Y \ud835\udc61\u22121),\ud835\udc50(\ud835\udc63) \ud835\udc61 = Attention(A(\ud835\udc63) \ud835\udc61 , Y \ud835\udc61\u22121), (3) \ud835\udc5d(\ud835\udc63|Y \ud835\udc61\u22121),\ud835\udc50\ud835\udc61= Attention \u0010 {\ud835\udc50(1) \ud835\udc61 , \u00b7 \u00b7 \u00b7 ,\ud835\udc50(\ud835\udc41) \ud835\udc61 }, Y \ud835\udc61\u22121 \u0011 . (4) The Attention operator, as well as the context vectors \ud835\udc50\ud835\udc61and {\ud835\udc50(\ud835\udc63) \ud835\udc61 }\ud835\udc41 \ud835\udc63=1 are defined below. Intuitively, the two-level attention enables scaling to a large number of videos and video lengths since it decomposes a joint distribution into the product of two conditional distributions. The image attention \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121, I) reflects the correlation between video frames and web-images. We first generate a context \f... ... Figure 4: The Attention operator. vector \u02c6 \ud835\udc50\ud835\udc61encoding the most relevant information in the web-images at time \ud835\udc61given the current summary Y \ud835\udc61\u22121: \ud835\udc5d(\ud835\udc3c|Y \ud835\udc61\u22121), \u02c6 \ud835\udc50\ud835\udc61= Attention(I, Y \ud835\udc61\u22121). (5) \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121, I) is then obtained by transforming the dot product between \u02c6 \ud835\udc50\ud835\udc61and the action representations, i.e., representations from not previously selected frames, into a distribution via a softmax. The query attention \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121,\ud835\udc5e, D) captures the correlation between the query\ud835\udc5e, the text data D and the summary at time \ud835\udc61. For this, we first weigh every video\u2019s text embedding by its similarity to the query. Next, we compute an attention over the weighted embeddings, given the current summary Y \ud835\udc61\u22121, via \ud835\udf0b(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121,\ud835\udc5e, D), \u02dc \ud835\udc50\ud835\udc61=Attention \u0010 (\ud835\udc5e\ud835\udc47\ud835\udc51(\ud835\udc63))\ud835\udc51(\ud835\udc63), Y \ud835\udc61\u22121 \u0011 . (6) The interpolation weights in Eq. (1) can be obtained by attending over the modalities\u2019 context vectors, \ud835\udc50\ud835\udc61, \u02c6 \ud835\udc50\ud835\udc61and \u02dc \ud835\udc50\ud835\udc61: [\ud835\udf07(1) \ud835\udc61 , \ud835\udf07(2) \ud835\udc61 , \ud835\udf07(3) \ud835\udc61 ], \u00b7 = Attention({\ud835\udc50\ud835\udc61, \u02c6 \ud835\udc50\ud835\udc61, MLP( \u02dc \ud835\udc50\ud835\udc61)}, Y \ud835\udc61\u22121), (7) where MLP is a multi-layer perceptron used to unify the dimensions of the three context vectors. We observe that if \ud835\udc50\ud835\udc61and \u02c6 \ud835\udc50\ud835\udc61are similar, their weights \ud835\udf07(1) \ud835\udc61 and \ud835\udf07(2) \ud835\udc61 are close, else more weight is given to video attention. The Attention operator, illustrated in Figure 4 and used multiple times above, takes as input a sequence of vectors U = {\ud835\udc62\ud835\udc56}|U | \ud835\udc56=1 with \ud835\udc62\ud835\udc56\u2208R\ud835\udc5aand the summary Y \ud835\udc61\u22121, embedded by an LSTM into a hidden state \u210e\ud835\udc61\u2208R\ud835\udc5b. The Attention operator provides as output a distribution \ud835\udc5d(\ud835\udc62\ud835\udc56) over the vectors {\ud835\udc62\ud835\udc56}|U | \ud835\udc56=1 and a context vector \ud835\udc50as a linear combination of elements in U by conditioning them on \u210e\ud835\udc61: \ud835\udc52\ud835\udc56= \ud835\udc64\ud835\udc47 1 tanh(\ud835\udc4a2[\ud835\udc62\ud835\udc56;\u210e\ud835\udc61]), \ud835\udc5d(\ud835\udc621), \u00b7 \u00b7 \u00b7 , \ud835\udc5d(\ud835\udc62|U |) = Softmax([\ud835\udc521, \u00b7 \u00b7 \u00b7 ,\ud835\udc52|U |]), (8) \ud835\udc50= |U | \u2211\ufe01 \ud835\udc56=1 \ud835\udc5d(\ud835\udc62\ud835\udc56)\ud835\udc62\ud835\udc56, (9) where \ud835\udc641 \u2208R\ud835\udc5band \ud835\udc4a2 \u2208R\ud835\udc5b\u00d7(\ud835\udc5b+\ud835\udc5a) are trainable weight parameters. The outputs of the Attention operator are the probabilities given in Eq. (8) and the context vector \ud835\udc50given in Eq. (9). Embeddings: The video frames X are embedded with a pre-trained CNN followed by a BiLSTM network. Web-images I are encoded with the same CNN. Textual embeddings D are computed for every video by averaging Glove word embeddings [49] from its associated title and description. Note that we normalize all embeddings. 3.3 Training with Policy Gradient Due to the limited annotated data and the subjectivity of the ground truth summaries, we train our model via reinforcement learning. The goal is to learn the policy \ud835\udf0b\ud835\udf03(\ud835\udc4e\ud835\udc61|Y \ud835\udc61\u22121,\ud835\udc5e, D, I) by maximizing the expected reward \ud835\udc3d(\ud835\udf03) = E\ud835\udf0b\ud835\udf03[\ud835\udc45(Y \ud835\udc3f)] during training, where \ud835\udc45(Y \ud835\udc3f) denotes the reward function computed for a summary Y \ud835\udc3f. Following REINFORCE [68], we approximate the expectation by running the agent for \ud835\udc40episodes for a batch of videos and then taking the average gradient. To reduce variance, we use a moving average of the rewards as a computationally efficient baseline. The reward \ud835\udc45= \ud835\udefd1\ud835\udc45div + \ud835\udefd2\ud835\udc45rep + \ud835\udefd3\ud835\udc45query + \ud835\udefd4\ud835\udc45coh is composed of four terms, measuring the diversity (\ud835\udc45div), representativeness (\ud835\udc45rep), query-adaptability (\ud835\udc45query) and temporal coherence (\ud835\udc45coh). Hyperparameters {\ud835\udefd\ud835\udc56}4 \ud835\udc56=1 are weights associated to different rewards. Note that we use the same diversity and representativeness rewards as Zhou et al. [81]. In addition, we introduce two novel rewards, query-adaptability and temporal coherence, to accommodate the QAMVS task. To keep the rewards in the same range, we use (1) dot product as a similarity metric in \ud835\udc45coh to balance out \ud835\udc45div and (2) a similar form to \ud835\udc45rep for \ud835\udc45query. The Diversity Reward measures the dissimilarity among the selected frames in the feature space via \ud835\udc45div(Y \ud835\udc3f) = 1 \ud835\udc3f(\ud835\udc3f\u22121) \u2211\ufe01 \ud835\udc66\ud835\udc61,\ud835\udc66\ud835\udc61\u2032 \u2208Y \ud835\udc3f \ud835\udc61\u2260\ud835\udc61\u2032 \u0010 1 \u2212\ud835\udc66\ud835\udc47 \ud835\udc61\ud835\udc66\ud835\udc61\u2032 \u0011 . (10) Intuitively, the more dissimilar the selected frames to each other, the higher the diversity reward the agent receives. The Representativeness Reward measures how well the generated summary represents the main events occurring in the collection of videos. Thus, the reward is higher when the selected frames are closer to the cluster centers. Formally, \ud835\udc45rep(Y \ud835\udc3f) =exp(\u22121 |X| \u2211\ufe01 \ud835\udc65\u2208X min \ud835\udc66\ud835\udc61\u2208Y \ud835\udc3f \u2225\ud835\udc65\u2212\ud835\udc66\ud835\udc61\u22252). (11) The Query-Adaptability Reward4 encourages the model to select the summary frames to be similar to the web-images I via \ud835\udc45query(Y \ud835\udc3f) = exp \u00a9 \u00ad \u00ab \u22121 \ud835\udc3f \u2211\ufe01 \ud835\udc66\ud835\udc61\u2208Y \ud835\udc3f min \ud835\udc3c\u2208I \u2225\ud835\udc66\ud835\udc61\u2212\ud835\udc3c\u22252\u00aa \u00ae \u00ac . (12) The Temporal Coherence Reward encourages the visual coherence of the generated summary via \ud835\udc45coh(Y \ud835\udc3f) = 1 \ud835\udc3f \u2211\ufe01 \ud835\udc66\ud835\udc61\u2208Y \ud835\udc3f \ud835\udf0c(\ud835\udc66\ud835\udc61), (13) 4Other explored forms include \ud835\udc45query(Y \ud835\udc3f) = \u22121 |I| \u00cd \ud835\udc3c\u2208I min \ud835\udc66\ud835\udc61\u2208Y\ud835\udc3f \u2225\ud835\udc66\ud835\udc61\u2212\ud835\udc3c\u22252 and \ud835\udc45query(Y \ud835\udc3f) = \u22121 \ud835\udc3f \u00cd \ud835\udc66\ud835\udc61\u2208Y\ud835\udc3f \u2225\ud835\udc66\ud835\udc61\u2212 1 |I| \u00cd \ud835\udc3c\u2208I \ud835\udc3c\u22252. We found the formulation in Eq. (12) to work best. \fwhere \ud835\udf0c(\ud835\udc66\ud835\udc61) is calculated by adding up the correlation between two consecutive frames: \ud835\udf0c(\ud835\udc66\ud835\udc61) = 1 2 \u2211\ufe01 \ud835\udc58\u2208{\u00b11} \ud835\udc66\ud835\udc47 \ud835\udc61\ud835\udc66\ud835\udc61+\ud835\udc58. (14) Hence, the more correlated the neighboring frames, the higher the temporal coherence reward. Note that optimizing for visual/temporal coherence, i.e., smoothness of the transitions, is just a proxy for chronological soundness, which is a much harder problem. 4 EXPERIMENTAL SETUP We describe experimental details, such as the evaluation dataset and metrics, and present quantitative and qualitative results, comparing the proposed DeepQAMVS model with several baselines. Our experiments aim to show that (1) SVS methods cannot properly address QAMVS and multi-stage MVS procedures result in lower performance than a unified system (sections 4.2 and 4.5), (2) the use of multi-modal information is crucial in guiding the summarization process (section 4.3), (3) the introduced novel temporal coherence reward generates more visually coherent summaries (section 4.4) and (4) our method reduces the computational complexity compared to the current state-of-the-art methods (section 4.6). 4.1 Experimental Settings Dataset: We perform our experiments on the MVS1K dataset [22]. MVS1K is a collection of 1000 videos on 10 queries (events), with associated web-images, video titles, and their text descriptions. Each query has 4 different user summaries, serving as a ground truth. Table 1 lists the events, the query used to retrieve them, the number of videos and query web-images for each event as well as the total number of input frames across all videos. Each video is associated with a title and a text description. We use the features introduced by Ji et al. [22]. The dimensionality of the video frame and webimage embeddings is 4352. The embeddings are composed of a 4096 dimensional VGGNet-19 [60] (trained on ImageNet) CNN feature vector concatenated with a 256 dimensional HSV color histogram feature vector. These embeddings are reduced to a vector of length 256 through a fully connected layer. The input frames to the model are selected such that they represent the segment centers obtained using the shot boundary detection algorithm [70]. The textual features (titles and descriptions) and the query are Glove embeddings [49] of dimension 100. We set the hidden state dimension of the LSTM and the pointer network to be 256 and 32, respectively. Evaluation Metrics: To compare with previous work, generated summaries are assessed using F1-score, averaged over the ground truth user summaries. Following prior work [22, 24, 25], two frames are considered to match when the pixel-level euclidean distance is smaller than a predefined threshold of 0.6. Training Details: We train using a 10-fold cross-validation scheme. Specifically, for evaluating each event, we use the remaining 9 events as training data. During training, we use a batch size of 32, where each sample consists of 10 randomly sampled videos per event. We limit the number of video combinations to 4000 for every event. This large number of random combinations allowed us to Table 1: Dataset Characteristics Query ID Query # Videos # Frames # Images 1 Britains Prince William wedding 2011 90 1124 324 2 Prince death 2016 104 1549 142 3 NASA discovers Earth-like planet 100 1349 226 4 American government shut-down 2013 82 962 177 5 Malaysia Airline MH370 109 1330 435 6 FIFA corruption scandal 2015 90 785 177 7 Obama re-election 2012 85 1263 207 8 Alpha go vs Lee Sedo 84 976 118 9 Kobe Bryant retirement 109 1140 221 10 Paris terror attacks 83 857 651 Total 936 2678 avoid overfitting despite the small number of events5. We optimize with Adam, 0.01 learning rate and \u21132 regularization. During testing, we use all the videos associated with an event in the test set. Since the diversity \ud835\udc45div and representativeness \ud835\udc45rep reward on one side, and the coherence reward \ud835\udc45coh on the other side are contradictory, i.e., \ud835\udc45div and \ud835\udc45rep encourage the selection of diverse frames while \ud835\udc45coh is high when the summary is smooth as measured by the similarity of the neighboring frames, we use a training schedule: (1) We set \ud835\udefd1 = \ud835\udefd2 = \ud835\udefd3 = 1/3 and \ud835\udefd4 = 0 for 60 epochs. (2) Then, set \ud835\udefd1 = \ud835\udefd2 = \ud835\udefd3 = \ud835\udefd4 = 1/4 for 30 additional epochs. We also experiment with different summary lengths \ud835\udc3f\u2208{30, 50, 60}. 4.2 Experimental Results We compare DeepQAMVS to five SVS baselines operating on the concatenated videos. We chose the SVS baselines such that they represent the main trends in unsupervised summarization: \u2022 \ud835\udc3e-means [10]: SVS method that clusters all video frames and then selects the one closest to the cluster centers as summary frames (\ud835\udc58= 9). \u2022 DSC [3]: Dominant Set Clustering (DSC) is a graph-based clustering method where a dominant set algorithm is used to extract the summary frames. \u2022 MSR [3]: Minimum Sparse Reconstruction (MSR) is a decomposition based approach, which formulates video summarization as a minimum sparse reconstruction. \u2022 SUM-GAN [39]: An adversarial LSTM model, where the generator is an autoencoder LSTM aiming at first selecting the summary frames then reconstructing the original video based on them, and the discriminator is trained to distinguish between the reconstructed video and the original one. \u2022 DSN [81]: uses a RNN trained with deep reinforcement learning with diversity and representativeness rewards. Moreover, we compare with four state-of-the-art QAMVS baselines: \u2022 QUASC [22]: QUASC is a sparse coding program regularized with interestingness, diversity and query-relevance metrics, followed by ordering the frames chronologically by grouping them into events based on textual and visual similarity. \u2022 MWAA [25]: MWAA is a two-stage approach, where the frames are first extracted using multi-modal Weighted Archetypal Analysis (MWAA), and then are chronologically ordered based on upload time and topic-closeness. 5Besides the proposed reinforcement learning framework, we experimented with training in a supervised fashion, however, we could not avoid over-fitting. \fTable 2: Comparison of our approach against baselines (F1 score). Query ID 1 2 3 4 5 6 7 8 9 10 AVG SVS k-means .576 .552 .568 .336 .457 .525 .651 .278 .384 .337 .466 DSC .578 .472 .399 .530 .407 .494 .533 .485 .529 .471 .490 MSR .472 .391 .370 .414 .396 .355 .418 .234 .384 .288 .372 SUM-GAN .620\u00b1.035 .481\u00b1.028 .519\u00b1.034 .501\u00b1.038 .413\u00b1.022 .455\u00b1.048 .458\u00b1.059 .459\u00b1.041 .510\u00b1.021 .395\u00b1.056 .486\u00b1 .075 DSN .529\u00b1.019 .327\u00b1.062 .478\u00b1.036 .407\u00b1.026 .325\u00b1.042 .453\u00b1.033 .616\u00b1.028 .375\u00b1.022 .469\u00b1.021 .384\u00b1.016 .436\u00b1.093 MVS QUASC .520 .513 .400 .570 .513 .538 .623 .439 .709 .588 .544 MVS-HDS .660 .552 .475 .526 .495 .520 .642 .469 .633 .581 .555 MWAA .705 .610 .553 .511 .563 .466 .664 .483 .611 .379 .555 Random-50 .600\u00b1.070 .349\u00b1.088 .288\u00b1.047 .492\u00b1.131 .255\u00b1.074 .352\u00b1.096 .265\u00b1.099 .429\u00b1.109 .326\u00b1.109 .284\u00b1.064 .364\u00b1.089 Ours-30 .570\u00b1.013 .491\u00b1.037 .421\u00b1.084 .519\u00b1.017 .458\u00b1.054 .476\u00b1.030 .369\u00b1.036 .372\u00b1.014 .403\u00b1.017 .368\u00b1.041 .446\u00b1.022 Ours-50 .706\u00b1.018 .563\u00b1.035 .525\u00b1.017 .553\u00b1.026 .549\u00b1.014 .486\u00b1.032 .524\u00b1.015 .486\u00b1.022 .690\u00b1.015 .542\u00b1.022 .561\u00b1.005 Ours-60 .722\u00b1.019 .530\u00b1.046 .495\u00b1.009 .508\u00b1.015 .541\u00b1.036 .487\u00b1.014 .614\u00b1.026 .474\u00b1.015 .674\u00b1.025 .573\u00b1.019 .562\u00b1.004 Ours-best .722\u00b1.019 .563\u00b1.035 .525\u00b1.017 .553\u00b1.026 .549\u00b1.014 .487\u00b1.014 .614\u00b1.026 .486\u00b1.022 .690\u00b1.015 .573\u00b1.019 .576\u00b1.017 Table 3: Summary length (# frames) across methods. Query ID 1 2 3 4 5 6 7 8 9 10 AVG SVS k-means 48 51 59 51 63 47 48 36 39 28 47.0 DSC 42 47 34 39 52 46 55 41 41 41 43.8 MSR 48 51 59 51 63 47 48 36 39 28 47.0 SUM-GAN 60 60 60 60 60 60 60 60 60 60 60.0 DSN 60 60 60 60 60 60 60 60 60 60 60.0 MVS QUASC 33 57 21 55 48 41 59 52 51 56 47.3 MVS-HDS 51 60 48 48 60 44 58 54 60 50 53.3 MWAA 49 75 46 39 49 37 60 36 39 39 46.9 Ours-best 60 50 50 50 50 60 60 50 50 60 53.0 \u2022 MVS-HDS [24]: MVS-HDS is a clustering-based procedure using a Hyper-graph Dominant Set, followed by a refinement step to filter frames that are most dissimilar to the query web-images, and a final step where the remaining candidates are ordered based on topic closeness. \u2022 Random-50: We also compare our method against a randomly generated summary with length 50. We present quantitative results of our approach in Table 2 and the number of summary frames selected by each approach in Table 3. More specifically, in Table 2, the reported numbers represent the mean and standard deviation obtained from 5 rounds of experiments. We report the F1-scores for summaries of length 30 (ours-30), 50 (ours-50) and 60 (ours-60), as well as the best obtained score (oursbest) when selecting the best summary length for every event. We observe that SVS methods have in general lower performance than MVS methods. In addition, our proposed end-to-end DeepQAMVS model, on average, outperforms all baselines. 4.3 Ablation Study We present an ablation study, examining the effect of different rewards and attention mechanisms in Table 4. We evaluate the average F1-score across all the events for the following combinations of the attention modalities: (1) only video frame attention (\ud835\udf07(2) \ud835\udc61 = \ud835\udf07(3) \ud835\udc61 = 0); (2) video frame and image attention (\ud835\udf07(3) \ud835\udc61 = 0); (3) video frame and query attention (\ud835\udf07(2) \ud835\udc61 = 0); and (4) video frame, Table 4: Ablation study on attention and rewards (\ud835\udc3f= 60). Reward Attention \ud835\udf07(2) \ud835\udc61 = 0 \ud835\udf07(3) \ud835\udc61 = 0 \ud835\udf07(3) \ud835\udc61 = 0 \ud835\udf07(2) \ud835\udc61 = 0 \ud835\udf07(\ud835\udc56) \ud835\udc61 \u22600 \ud835\udefd2 = \ud835\udefd3 = \ud835\udefd4 = 0 .323\u00b1 .013 .559\u00b1.008 .374\u00b1 .015 .560\u00b1 .008 \ud835\udefd3 = \ud835\udefd4 = 0 .321\u00b1 .011 .557\u00b1.002 .373\u00b1 .002 .559\u00b1 .001 \ud835\udefd4 = 0 \u2212 .561\u00b1.003 \u2212 .562\u00b1 .006 \ud835\udefd\ud835\udc56\u22600 .330\u00b1 .020 .559\u00b1.005 .375\u00b1 .017 .562\u00b1 .004 image and query attention (\ud835\udf07(\ud835\udc56) \ud835\udc61 \u22600, \u2200\ud835\udc56\u2208{1, 2, 3}). We also investigate the effect of the different rewards by incrementally adding the reward terms including, (1) \ud835\udc45div (\ud835\udefd2 = \ud835\udefd3 = \ud835\udefd4 = 0); (2) \ud835\udc45div and \ud835\udc45query (\ud835\udefd3 = \ud835\udefd4 = 0); (3) \ud835\udc45div, \ud835\udc45query and \ud835\udc45coh (\ud835\udefd4 = 0); and (4) all the rewards, i.e., \ud835\udefd\ud835\udc56\u22600, \u2200\ud835\udc56\u2208{1, \u00b7 \u00b7 \u00b7 , 4}. Note that we do not add the query reward \ud835\udc45query when testing with attention terms that do not include the image attention (\u2212in Table 4). When considering all forms of attention (last column), we found that \ud835\udc45div has barely improved the F1-score. In contrast, including \ud835\udc45query, helped improve the quality of the summary while adding the coherency reward \ud835\udc45coh did not lead to a consistent increase of the F1-score. This is expected as the ground truth summary consists of an unordered set of frames. However, as demonstrated by the user study below, \ud835\udc45coh helped generating more visually coherent summaries. Across the different combinations of rewards, we observe that the combination of video frame attention and image attention (column 3) yields overall a higher F1-score than the combination of video frame attention and query attention (column 4). This is due to video descriptions being noisy and associated with the whole video, unlike the web-images, which are embedded in the same space as the frames and hence better capture queryadaptability. The best results are obtained by using all the attention terms (last column), demonstrating the complementary properties of the multimodal information. 4.4 Temporal Coherence User Study Since the provided ground truth summaries are composed of an unordered collection of frames, we resort to a user study to assess the visual coherence of our generated summaries. In total 21 participants are presented with 3 summaries generated from (1) DeepQAMVS, (2) random permutation of the video segments in \fHDS (2|\ud835\udfd2)  SUM-GAN (0|\ud835\udfd6)  DSN (0|\ud835\udfd1)  K-Means (6|\ud835\udfd5)  DSC (0|4)  MSR (0|\ud835\udfd5)  QUASC OURS DSN SUM-GAN QUASC OURS DSN SUM-GAN QUASC OURS DSN SUM-GAN Unimportant Redundant QUASC OURS DSN SUM-GAN QUASC (0|\ud835\udfd1)  OURS (0|\ud835\udfcf)  Figure 5: Qualitative results for event 1 (Prince William Wedding) by \ud835\udc3e-means [10], DSC [3], MSR [3], QUASC [22], MVSHDS [24] and DeepQAMVS, respectively. Frames outlined in red indicate unimportant keyframes, while yellow ones show redundant ones. The number of unimportant and redundant frames are reported on top of every summary. 1 2 3 4 5 6 7 8 9 10 AVG 20 % 40 % 60 % 80 % participants (%) DeepQAMVS Random DeepQAMVSwo Figure 6: Temporal coherence user study for Query IDs (\ud835\udc65-axis). 6 10 4 8 1 9 7 5 3 2 AVG 0.4 0.5 0.6 0.7 Run time (in sec.) L=30 L=50 L=60 Figure 7: Run Time Analysis in seconds. Query IDs (\ud835\udc65-axis) ordered by total number of input frames. the DeepQAMVS summary (Random), and (3) DeepQAMVS trained without the temporal coherence reward (DeepQAMVSwo). The participants are asked to select the most coherent summary, paying special attention to transitions between different segments in each video. From Figure 6, we can see that users preferred our DeepQAMVS summary in 8 out of 10 events. For events 5 \u2018Malaysian Airline MH370\u2019 and 10 \u2018Paris Attack\u2019, users preferred the summaries generated by DeepQAMVSwo. Note that these two events deal with major news incidents and consequently mostly consist of visually similar newscaster segments. In this case, users most likely prefer the resulting summaries from DeepQAMVSwo, as it produces more visually varied summaries due to the higher importance of the diversity reward. 4.5 Qualitative Results Figure 5 illustrates the summaries generated by different methods for the query Prince William Wedding (event 1). Visually, we observe that SVS methods choose many irrelevant frames. This is expected as these methods just optimize for diversity and do not take query information into account. QUASC, MWAA and HDS on the other hand have fewer irrelevant frames as they use the webimages to further guide the summarization. Compared to baselines, our method generates summaries with high diversity and selects less unimportant (red bounding box) or redundant frames (yellow bounding box). 4.6 Run-Time Analysis For completeness, we report the run-time of our model in Figure 7 for summary lengths 30, 50 and 60. We observe that we scale linearly with the number of input frames and summary length. We do not have access to any QAMVS baseline implementations to measure \f(a) \ud835\udc6d1 =.39, \ud835\udc45\ud835\udc51\ud835\udc56\ud835\udc63=.68, \ud835\udc45\ud835\udc5f\ud835\udc52\ud835\udc5d=.60, \ud835\udc45\ud835\udc5e\ud835\udc62\ud835\udc52\ud835\udc5f\ud835\udc66=.65, \ud835\udc45\ud835\udc50\ud835\udc5c\u210e=.29 (b) \ud835\udc6d1 =.31, \ud835\udc45\ud835\udc51\ud835\udc56\ud835\udc63=.67, \ud835\udc45\ud835\udc5f\ud835\udc52\ud835\udc5d=.63, \ud835\udc45\ud835\udc5e\ud835\udc62\ud835\udc52\ud835\udc5f\ud835\udc66=.67, \ud835\udc45\ud835\udc50\ud835\udc5c\u210e=.43 Figure 8: Failure case from event 7 (Obama Re-election). Although, the summary constructed from the ground-truth (left) and the DeepQAMVS generated one (right) are visually and reward-wise comparable, yet there is a remarkable difference in their corresponding F1-scores. run-times, but complexity-wise, they all scale polynomially with the number of input frames. 4.7 Limitations and Future Work Figure 8 presents a comparison of two summaries, the ground truth summary (left, (a)) and the summary generated by our DeepQAMVS (right, (b)). While both summaries have high diversity, representativeness and query-adaptability rewards, (b) has a lower F1-score compared to (a). This showcases the limitations of (1) the F1-score as a metric to assess the summary and (2) the subjectivity of the ground truth summaries. The F1-score relies solely on the visual overlap between the selected frames and the ground truth using pixel-level distances, which are highly sensitive to zooming, shifting and camera angle. In fact, Otani et al. [42] showed that randomly generated summaries achieve comparable or better performance to the state-ofthe-art methods when evaluated using the F1-score on two SVS datasets, SumMe [18] and TVSum [61]. Note that the ground truth in their case consists of importance scores associated with every frame. Otani et al. [42] proposed a new evaluation protocol based on the correlation between the ranking of the estimated scores and the human-annotated ones (Kendall [27] and Spearman [83] correlation coefficients). This metric shows the expected intuition, i.e., across human-annotated summaries, the correlation metric is high. In contrast, the correlation between the randomly generated and state-of-the-art summarization methods is small. Unfortunately, this metric is not applicable to QAMVS. To see this consider the following: if the ground truth consists of importance scores, redundant frames representing an important event will have high scores across videos. Hence, a ranked list of ground truth scores contains redundant frames, which leads to a sub-optimal summary resulting in high Spearman/Kendall scores. To fix this, we believe that a metric combining visual, textual and temporal order overlap would lead to a better evaluation protocol. Few papers have proposed metrics based on the textual overlap in the past. In particular, Yeung et al. [69] annotated segments in videos with sentences. The ground truth and selected segments are compared using a similarity metric for text summarization (ROUGE). Textual annotation could be very expensive for QAMVS. However, recent advances in image captioning could be leveraged to automate the process. In this paper, we design a user study to assess the coherence of the produced summaries. However, user-studies are expensive, subjective and not reproducible. Instead, a ranking correlation measure between a list of textual concepts from the ordered ground truth frames and the ones from the proposed summary may serve as a better metric, similar to [42]. Beyond the evaluation metric, training to optimize for the temporal coherence still has room for improvement. Although using the proposed reward results in visually smoother transitions, it did not lead to an overall clear story in the final summary. Embedding frames/web-images in a shared vision-language domain [50] could permit to leverage advances in text summarization. Also, the field could benefit from new benchmarks with more events and shotlevel text annotations to enable a wider range of techniques and evaluation metrics. 5"
+                },
+                {
+                    "url": "http://arxiv.org/abs/2005.01508v2",
+                    "title": "Can We Learn Heuristics For Graphical Model Inference Using Reinforcement Learning?",
+                    "abstract": "Combinatorial optimization is frequently used in computer vision. For\ninstance, in applications like semantic segmentation, human pose estimation and\naction recognition, programs are formulated for solving inference in\nConditional Random Fields (CRFs) to produce a structured output that is\nconsistent with visual features of the image. However, solving inference in\nCRFs is in general intractable, and approximation methods are computationally\ndemanding and limited to unary, pairwise and hand-crafted forms of higher order\npotentials. In this paper, we show that we can learn program heuristics, i.e.,\npolicies, for solving inference in higher order CRFs for the task of semantic\nsegmentation, using reinforcement learning. Our method solves inference tasks\nefficiently without imposing any constraints on the form of the potentials. We\nshow compelling results on the Pascal VOC and MOTS datasets.",
+                    "authors": "Safa Messaoud, Maghav Kumar, Alexander G. Schwing",
+                    "published": "2020-04-27",
+                    "updated": "2020-05-05",
+                    "primary_cat": "cs.CV",
+                    "cats": [
+                        "cs.CV",
+                        "I.4.6, I.2.6"
+                    ],
+                    "main_content": "Introduction Graphical model inference is an important combinatorial optimization task for robotics and autonomous systems. Despite signi\ufb01cant progress in recent years due to increasingly accurate deep net models, challenges such as inconsistent bounding box detection, segmentation or image classi\ufb01cation remain. Those inconsistencies can be addressed with Conditional Random Fields (CRFs), albeit requiring to solve an inference task which is of combinatorial complexity. Classical algorithms to address combinatorial problems come in three paradigms: exact, approximate and heuristic. Exact algorithms are often based on solving an Integer Linear Program (ILP) using a combination of a Linear Programming (LP) relaxation and a branch-and-bound framework. Particularly for large problems, repeated solving of linear programs is computationally expensive and therefore prohibitive. Approximation algorithms address this concern, however, often at the expense of weak optimality guarantees. Moreover, approximation algorithms often involve manual construction for each problem. Seemingly easier to develop are heuristics which are generally computationally fast but guarantees are hardly provided. In addition, tuning of hyperparameters for a particular problem instance may be required. A fourth paradigm has been considered since the early 2000s and gained popularity again recently [93, 6, 85, 5, 27, 18]: learned algorithms. This fourth paradigm is based on the intuition that data governs the properties of the combinatorial algorithm. For instance, semantic image segmentation always deals with similarly sized problem structures or semantic patterns. It is therefore conceivable that learning to solve the problem on a given dataset uncovers strategies which are close to optimal but hard to \ufb01nd manually, since it is much more effective for a learning algorithm to sift through large amounts of sample problems. To achieve this, in a series of work, reinforcement learning techniques were developed [93, 6, 85, 5, 27, 18] and shown to perform well on a variety of combinatorial tasks from the traveling salesman problem and the knapsack formulation to maximum cut and minimum vertex cover. While the aforementioned learning based techniques have been shown to perform extremely well on classical benchmarks, we are not aware of results for inference algorithms in CRFs for semantic segmentation. We hence wonder whether we can learn heuristics to address graphical model inference in semantic segmentation problems? To study this we develop a new framework for higher order CRF inference for the task of semantic segmentation using a Markov Decision Process (MDP). To solve the MDP, we assess two reinforcement learning algorithms: a Deep Q-Net (DQN) [58] and a deep net guided Monte Carlo Tree Search (MCTS) [82]. The proposed approach has two main advantages: (1) Unlike traditional approaches, it does not impose any constraints on the form of the CRF terms to facilitate effective inference. We demonstrate our claim by designing detection based higher order potentials that result in computationally intractable classical inference approaches. (2) Our method is more ef\ufb01cient than traditional approaches as inference complexity is linear in arbitrary potential orders while classical methods have exponential dependence on the largest clique size in general. This is due to the fact that semantic segmentation is reduced to sequentially inferring the labels 1 arXiv:2005.01508v2  [cs.CV]  5 May 2020 \fReward Sec 3.4 Node Embedding Superpixel Pooling Output Unaries    (PSPNet) Sec 3.6 GNN Policy Network Sec 3.3 CRF Energy   Sec 3.2 Groud Truth Input  Higher Order Potentials    (Bounding Boxes YoloV2)  Sec 3.6 Binaries    (Hypercolumns VGG16) Sec 3.6 Figure 1: Pipeline of the proposed approach. Inference in a higher order CRF is solved using reinforcement learning for the task of semantic segmentation. For Pascal VOC, unaries are obtained from PSPNet [94], pairwise potentials are computed using hypercolumns from VGG16 [30] and higher order potentials are based on detection bounding boxes from YoloV2 [69]. The policy network is modeled as a graph embedding network [17] following the CRF graph structure. It sequentially produces the labeling of every node (superpixel). of every variable based on a learned policy, without use of any iterative or search procedure. We evaluate the proposed approach on two benchmarks: (1) the Pascal VOC semantic segmentation dataset [19], and (2) the MOTS multi-object tracking and segmentation dataset [86]. We demonstrate that our method outperforms traditional inference algorithms while being more ef\ufb01cient. 2. Related Work We \ufb01rst review work on semantic segmentation before discussing learning of combinatorial optimizers. Semantic Segmentation: In early 2000, classi\ufb01ers were locally applied to images to generate segmentations [42] which resulted in a noisy output. To address this concern, as early as 2004, He et al. [33] applied Conditional Random Fields (CRFs) [43] and multi-layer perceptron features. For inference, Gibbs sampling was used, since MAP inference is NP-hard due to the combinatorial nature of the program. Progress in combinatorial optimization for \ufb02ow-based problems in the 1990s and early 2000s [21, 23, 26, 9, 7, 8, 10, 40] showed that min-cut solvers can \ufb01nd the MAP solution of sub-modular energy functions of graphical models for binary segmentation. Approximation algorithms like swapmoves and \u03b1-expansion [10] were developed to extend applicability of min-cut solvers to more than two labels. Semantic segmentation was further popularized by combining random forests with CRFs [81]. Recently, the performance on standard semantic segmentation benchmarks like Pascal VOC 2012 [19] has been dramatically boosted by convolutional networks. Both deeper [48] and wider [61, 71, 92] network architectures have been proposed. Advances like spatial pyramid pooling [94] and atrous spatial pyramid pooling [15] emerged to remedy limited receptive \ufb01elds. Other approaches jointly train deep nets with CRFs [16, 78, 28, 79, 52, 14, 96] to better capture the rich structure present in natural scenes. CRF Inference: Algorithmically, to \ufb01nd the MAP con\ufb01guration, LP relaxations have been extensively studied in the 2000s [74, 13, 41, 39, 22, 88, 34, 83, 35, 68, 89, 54, 53, 36, 75, 76, 77, 55, 56]. Also, CRF inference was studied as a differentiable module within a deep net [95, 51, 57, 24, 25]. However, both directions remain computationally demanding, particularly if high order potentials are involved. We therefore wonder whether recent progress in learning based combinatorial optimization yields effective algorithms for high order CRF inference in semantic segmentation. Learning-based Combinatorial Optimization: Decades of research on combinatorial optimization, often also referred to as discrete optimization, uncovered a large amount of valuable exact, approximation and heuristic algorithms. Already in the early 2000s, but more prominently recently [93, 6, 85, 5, 27, 18], learning based algorithms have been suggested for combinatorial optimization. They are based on the intuition that instances of similar problems are often solved repeatedly. While humans have uncovered impressive heuristics, data driven techniques are likely to uncover even more compelling mechanisms. It is beyond the scope of this paper to review the vast literature on combinatorial optimization. Instead, we subsequently focus on learning based methods. Among the \ufb01rst is work by Boyan and Moore [6], discussing how to learn to predict the outcome of a local search algorithm in order to bias future search trajectories. Around the same time, reinforcement learning techniques were used to solve resourceconstrained scheduling tasks [93]. Reinforcement learning is also the technique of choice for recent approaches addressing NP-hard tasks [5, 27, 18, 45] like the traveling salesman, \f\u008e1 \u0019( | ) \u2208 w1 \u00881 \u211dj\u00d7|\ue238| \u0000\u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t  \u000b\f\r \u000e \u000f \u0010\u0011\u0012\u0013\u0014 \u2211 \u0015\u0016 \u0017 \u0018\u0019\u001a\u001b\u001c \u001d \u001e\u001f  !\" = \u2205 \u00881 # $ % & ' () *+ ,./012 3 4 5 6 7 89 : ; < => ? @ AB C ~1 DE FG H IJ K L M NOPQ = ( , ) w\u2217 1 ~\u2217 1 \u008e~\u2217 1 RS TU VW X Y Z[\\] ^ = ({ }, ( )) \u00882 ~\u2217 1 \u008e{ } ~\u2217 1 ~1 Figure 2: Illustration of one iteration of reinforcement learning for the inference task. The policy network samples an action a1 = (i\u2217 1, yi\u2217 1) from the learned distribution \u03c0(a1|s1) \u2208RN\u00d7|L| at iteration t = 1. knapsack, maximum cut, and minimum vertex cover problems. Similarly, promising results exist for structured prediction problems like dialog generation [46, 90, 31], program synthesis [12, 50, 65], semantic parsing [49], architecture search [97], chunking and parsing [80], machine translation [67, 62, 4], summarization [63], image captioning [70], knowledge graph reasoning [91], query rewriting [60, 11] and information extraction [59, 66]. Instead of directly learning to solve a given program, machine learning techniques have also been applied to parts of combinatorial solvers, e.g., to speed up branch-and-bound rules [44, 73, 32, 38]. We also want to highlight recent work on learning to optimize for continuous problems [47, 2]. Given those impressive results on challenging real-world problems, we wonder: can we learn programs for solving higher order CRFs for semantic image segmentation? Since CRF inference is typically formulated as a combinatorial optimization problem, we want to know how recent advances in learning based combinatorial optimization can be leveraged. 3. Approach We \ufb01rst present an overview of our approach before we discuss the individual components in greater detail. 3.1. Overview Graphical models factorize a global energy function as a sum of local functions of two types: (1) local evidence; and (2) co-occurrence information. Both cues are typically obtained from deep net classi\ufb01ers which are combined in a joint energy formulation. Finding the optimal semantic segmentation con\ufb01guration, i.e., \ufb01nding the minimizing argument of the energy, generally involves solving an NP-hard combinatorial optimization problem. Notable exceptions include energies with sub-modular co-occurrence terms. Instead of using classical directions, i.e., heuristics, exhaustive search, or relaxations, here, we assess suitability of learning based combinatorial optimization. Intuitively, we argue that CRF inference for the task of semantic segmentation exhibits an inherent similarity which can be exploited by learning based algorithms. In spirit, this mimics the design of heuristic rules. However, different from hand-crafting those rules, we use a learning based approach. To the best of our knowledge, this is the \ufb01rst work to successfully apply learning based combinatorial optimization to CRF inference for semantic segmentation. We therefore \ufb01rst provide an overview of the developed approach, outlined in Fig. 1. Just like classical approaches, we also use local evidence and co-occurrence information, obtained from deep nets. This information is consequently used to form an energy function de\ufb01ned over a Conditional Random Field (CRF). An example of a CRF with variables corresponding to superpixels (circles), pairwise potentials (edges) and higher order potentials obtained from object detections (fully connected cliques) is illustrated in Fig. 1. However, different from classical methods, we \ufb01nd the minimizing con\ufb01guration of the energy by repeatedly applying a learned policy network. In every iteration, the policy network selects a random variable, i.e., the pixel and its label by computing a probability distribution over all currently unlabeled pixels and their labels. Speci\ufb01cally, the pixel and label are determined by choosing the highest scoring entry in a matrix where the number of rows and columns correspond to the currently unlabeled pixels and the available labels respectively, as illustrated in Fig. 9. 3.2. Problem Formulation Formally, given an image x, we are interested in predicting the semantic segmentation y = (y1, . . . , yN) \u2208 Y. Hereby, N denotes the total number of pixels or superpixels, and the semantic segmentation of a superpixel i \u2208{1, . . . , N} is referred to via yi \u2208L = {1, . . . , |L|}, which can be assigned one out of |L| possible discrete labels from the set of possible labels L. The output space is denoted Y = LN. Classical techniques obtain local evidence fi(yi) for every pixel or superpixel, and co-occurrence information in the form of pairwise potentials fij(yi, yj) and higher order potentials fc(yc). The latter assigns an energy to a clique c \u2286{1, . . . , N} of variables yc = (yi)i\u2208c. For readability, we drop the dependence of the energies fi, fij and fc on the image x and the parameters of the employed deep nets. The goal of energy based semantic segmentation is to \ufb01nd the con\ufb01guration y\u2217which has the lowest energy E(y), i.e., y\u2217=arg min y\u2208Y E(y)\u225c N X i=1 fi(yi) + X (i,j)\u2208E fij(yi, yj) + X c\u2208C fc(yc). (1) Hereby, the sets E and C subsume respectively the captured set of pairwise and higher order co-occurrence patterns. Details about the potentials are presented in Sec. 3.6. \fAlgorithm 1: Inference Procedure 1: s1 = \u2205; 2: for t = 1 to N do 3: a\u2217 t = arg maxat\u2208At \u03c0(at|st) 4: (i\u2217 t , yi\u2217 t ) \u2190a\u2217 t 5: st+1 = st \u2295(i\u2217 t , yi\u2217 t ) 6: end for 7: Return: \u02c6 y \u2190sN+1 Solving the combinatorial program given in Eq. (1), i.e., inferring the optimal con\ufb01guration y\u2217is generally NP-hard. Different from existing methods, we develop a learning based combinatorial optimization heuristic for semantic segmentation with the intention to better capture the intricacies of energy minimization than can be done by hand-crafting rules. The developed heuristic sequentially labels one variable yi, i \u2208{1, . . . , N}, at a time. Formally, selection of one superpixel at a time can be formulated in a reinforcement learning context, as shown in Fig. 9. Speci\ufb01cally, an agent operates in t \u2208{1, . . . , N} time-steps according to a policy \u03c0(at|st) which encodes a probability distribution over actions at \u2208At given the current state st. The current state subsumes in selection order the indices of all currently labeled variables It \u2286{1, . . . , N} as well as their labels yIt = (yi)i\u2208It, i.e., st \u2208{(It, yIt) : It \u2286{1, . . . , N}, yIt \u2208L|It|}. We start with s1 = \u2205. The set of possible actions At is the concatenation of the label spaces L for all currently unlabeled pixels j \u2208{1, . . . , N} \\ It, i.e., At = L j\u2208{1,...,N}\\It L. We emphasize the difference between the concatenation operator and the product operator used to obtain the semantic segmentation output space Y = LN, i.e., the proposed approach does not operate in the product space. As mentioned before, the policy \u03c0(at|st) results in a probability distribution over actions at \u2208At from which we greedily select the most probable action a\u2217 t = arg max at\u2208At \u03c0(at|st). The most probable action a\u2217 t can be decomposed into the index for the selected variable, i.e., i\u2217 t and its state yi\u2217 t \u2208 L. We obtain the subsequent state st+1 by combining the extracted variable index i\u2217 t and its labeling with the previous state st. Speci\ufb01cally, we obtain st+1 = st \u2295(i\u2217 t , yi\u2217 t ) by slightly abusing the \u2295-operator to mean concatenation to a set and a list maintained within a state. Formally, we summarize the developed reinforcement learning based semantic segmentation algorithm used for inferring a labeling \u02c6 y in Alg. 1. In the following, we describe the policy function \u03c0\u03b8(at|st), which we found to work well for semantic segmentation, and different variants to learn its parameters \u03b8. 3.3. Policy Function We model the policy function \u03c0\u03b8(at|st) using a graph embedding network [17]. The input to the network is a weighted graph G(V, E, w), where nodes V = {1, . . . , N}, correspond to variables, i.e., in our case superpixels, E is a set of edges connecting neighboring superpixels, as illustrated in Fig. 1 and w : E \u2192R+ is the edge weight function. The weights {w(i, j)}{j:(i,j)\u2208E} on the edges between a given node i and its neighbors {j : (i, j) \u2208E} form a distribution, obtained by normalizing the dot product between the hypercolumns [30] gi and gj via a softmax across neighbors. At every iteration, the state st is encoded in the graph G by tagging node i \u2208V with a scalar hi = 1 if the node is part of the already labeled set It, i.e., if i \u2208It and 0 otherwise. Moreover, a one-hot encoding \u02dc yi \u2208{0, 1}|L| encodes the selected label of nodes i \u2208It. We set \u02dc yi to equal the all zeros vector if node i has not been selected yet. Every node i \u2208V is represented by a p-dimensional embedding, where p is a hyperparameter. The embedding is composed of \u02dc yi, hi as well as superpixel features bi \u2208RF which encode appearance and bounding box characteristics that we discuss in detail in Sec. 4. The output of the network is a |L|-dimensional vector \u03c0i for each node i \u2208V , representing the scores of the |L| different labels for variable i. The network iteratively generates a new representation \u00b5(k+1) i for every node i \u2208V by aggregating the current embeddings \u00b5(k) i according to the graph structure E starting from \u00b5(0) i = 0, \u2200i \u2208V . After K steps, the embedding captures long range interactions between the graph features as well as the graph properties necessary to minimize the energy function E. Formally, the update rule for node i is \u00b5(k+1) i \u2190Relu \uf8eb \uf8ed\u03b8(k) 1 hi+\u03b8(k) 2 \u02dc yi+\u03b8(k) 3 bi+\u03b8(k) 4 X j:(i,j)\u2208E w(i, j)\u00b5(k) j \uf8f6 \uf8f8, (2) where \u03b8(k) 1 \u2208Rp, \u03b8(k) 2 \u2208Rp\u00d7|L| , \u03b8(k) 3 \u2208Rp\u00d7F and \u03b8(k) 4 \u2208 Rp\u00d7p are trainable parameters. After K steps, \u03c0i for every unlabeled node i \u2208{1, . . . , N} \\ It is obtained via \u03c0i = \u03b85\u00b5(K) i \u2200i \u2208{1, . . . , N} \\ It, (3) where \u03b85 \u2208R|L|\u00d7p is another trainable model parameter. We illustrate the policy function \u03c0\u03b8(at|st) and one iteration of inference in Fig. 9. 3.4. Reward Function: To train the policy, ideally, the reward function rt(st, at) is designed such that the cumulative reward coincides exactly with the objective function that we aim at maximizing, i.e., PN t=1 rt(st, at) = \u2212E(\u02c6 y), where \u02c6 y is extracted from \fTable 1: Illustration of the energy reward computation following the two proposed reward schemes on a fully connected graph with 3 nodes. t it Et rt = \u2212(Et \u2212Et\u22121) rt = \u00b11 Graph 0 \u2212 0 \u2212 \u2212 1 2 3 1 1 f1(y1) \u2212f1(y1) \u2212 1+2\u00b7 1{(Et(y1)<Et(\u02c6 y1))\u2200\u02c6 y1} 1 2 3 2 2 f1(y1)+f2(y2)+f12(y1, y2) \u2212f2(y2)\u2212f12(y1, y2) \u2212 1+2\u00b7 1{(Et(y1,y2)<Et(y1,\u02c6 y2))\u2200\u02c6 y2} 1 2 3 3 3 f1(y1)+f2(y2) + f3(y3) +f12(y1, y2) \u2212f3(y3)\u2212f23(y2, y3) \u2212 1+2\u00b7 1{(Et(y1,y2,y3)<Et(y1,y2,\u02c6 y3))\u2200\u02c6 y3} 1 2 3 + f23(y2, y3) +f13(y1, y3)+f{1,2,3}(y1, y2, y3) \u2212 f13(y1, y3) \u2212f{1,2,3}(y1, y2, y3) sN+1. Hence, at step t, we de\ufb01ne the reward as the difference between the value of the negative new energy Et and the negative energy from the previous step Et\u22121, i.e., rt(st, at) = Et\u22121(yIt\u22121) \u2212Et(yIt), where E0 = 0. Potentials depending on variables that are not labeled at time t are not incorporated in the evaluation of Et(yIt). We also study a second scheme, where the reward is truncated to +1 or \u22121, i.e., rt(st, at) \u2208{\u22121, 1}. For every selected node it, with label yit, we compare the energy function Et(yIt) with the one obtained when using all other labels \u02c6 yit \u2208L \\ yit. If the chosen label yit results in the lowest energy, the obtained reward is +1, otherwise it is \u22121. Note that the unary potentials result in a reward for every time step. Pairwise and high order potentials result in a sparse reward as their value is only available once all the superpixels forming the pair or clique are labeled. We illustrate the energy and reward computation on a graph with three fully connected nodes in Tab. 1. 3.5. Learning Policy Parameters To learn the parameters \u03b8 of the policy function \u03c0\u03b8(at|st), a plethora of reinforcement learning algorithms are applicable. To provide a careful assessment of the developed approach, we study two different techniques, Q-learning and Monte-Carlo Tree Search, both of which we describe next. Q-learning: In the context of Q-learning, we interpret the |L|-dimensional policy network output vector corresponding to a currently unlabeled node i \u2208{1, . . . , N} \\ It as the Q-values Q(st, at; \u03b8) associated to the action at of selecting node i and assigning label yi \u2208L. Since we only consider actions to label currently unlabeled nodes we obtain a total of |At| different Q-values. We perform standard Q-learning and minimize the squared loss (z \u2212Q(st, at; \u03b8))2, where we use target z = \u03b3 maxa\u2032 Q(st+1, a\u2032; \u03b8) + rt(st, at) for a non-terminal state. The reward is denoted rt and detailed above. The terminal state is reached when all the nodes are labeled. Instead of updating the Q-function based on the current sample (st, at, rt(st, at), st+1), we use a replay memory populated with samples (graphs) from previous episodes. In every iteration, we select a batch of samples and perform stochastic gradient descent on the squared loss. During the exploration phase, beyond random actions, we encourage the following three different sets of actions to generate more informative rewards for training: (1) M1: Choosing nodes that are adjacent to the already selected ones in the graph. Otherwise, the reward will only be based on the unary terms as the pairwise term is only evaluated if the neighbors are labeled (t = 2 in Tab. 1); (2) M2: Selecting nodes with the lowest unary distribution entropy. The low entropy indicates a high con\ufb01dence of the unary deep net. Hence, the labels of the corresponding nodes are more likely to be correct and provide useful information to neighbors with higher entropy in the upcoming iterations. (3) M3: Assigning the same label to nodes forming the same higher order potential. Further details are in Appendix B. Monte-Carlo Tree Search: While DQN tries to learn a policy from looking at samples representing one action at a time, MCTS has the inherent ability to update its policy after looking multiple steps ahead via a tree search procedure. At training time, through extensive simulations, MCTS builds a statistics tree, re\ufb02ecting an empirical distribution \u03c0MCTS(at|st). Speci\ufb01cally, for a given image, a node in the search tree corresponds to the state st in our formulation and an edge corresponds to a possible action at. The root node is initialized to s1 = \u2205. The statistics stored at every node correspond to (1) N(st): the number of times state st has been reached, (2) N(at|st): the number of times action at was chosen in state st in all previous simulations, as well as (3) \u02dc rt(st, at): the averaged reward across all simulations starting at st and taking action at. The MCTS policy is de\ufb01ned as \u03c0MCTS(at|st) = N(at|st) N(st) . The simulations follow an exploration-exploitation procedure modeled by a variant of the Probabilistic Upper Con\ufb01dence Bound (PUCB) [82]: U(at, st) = \u02dc rt(st,at) N(at|st) + \u03c0\u03b8(at|st) \u221a N(st) 1+N(at|st). During exploration, we additionally encourage the same action sets M1, M2 and M3 used for DQN. Also, similarly to DQN, the generated experiences (st, \u03c0MCTS) are stored in a replay buffer. The policy network is then trained through a cross entropy loss L(\u03b8) = \u2212 X s X a \u03c0MCTS(a|s) log \u03c0\u03b8(a|s). (4) to mach the empirically constructed distribution. Here, the second sum is over all valid actions from a state s sampled from the replay buffer and \u03c0MCTS(a|s) is the corresponding empirically estimated distribution. \fTable 2: Performance results for the minimizing the energy function Et under reward scheme 1 (R1 t = \u2212(Et \u2212Et\u22121)) and reward scheme 2 (R2 t = \u00b11). Nodes Metrics Supervised Unary Unary + Pairwise Unary + Pairwise + HOP1 Unary + Pairwise + HOP1 + HOP2 BP R1 t R2 t BP TBP DD L-Flip \u03b1-Exp R1 t R2 t BP TBP DD L-Flip \u03b1-Exp R1 t R2 t R1 t R2 t DQN MCTS DQN MCTS DQN MCTS DQN MCTS DQN MCTS DQN MCTS DQN MCTS DQN MCTS 50 IoU (sp) 85.21 88.59 88.04 88.19 88.59 88.59 88.73 88.73 88.73 88.73 88.72 43.31 66.51 87.91 88.73 89.26 89.27 89.27 89.27 88.58 57.43 73.37 89.55 89.66 58.34 73.85 90.05 90.09 Pascal VOC IoU (p) 69.05 72.56 70.77 71.99 72.56 72.56 72.43 72.43 72.43 72.43 72.43 38.54 38.75 72.16 72.43 72.59 72.59 72.59 72.60 72.35 51.88 53.71 72.83 72.85 50.53 51.71 72.94 72.95 250 IoU (sp) 83.54 88.01 87.29 88.01 88.01 88.01 88.10 88.10 88.10 88.10 88.10 88.06 88.22 88.56 88.52 88.54 88.53 88.55 88.54 88.07 60.60 64.82 88.94 88.91 82.19 81.89 89.30 89.57 IoU (p) 75.88 80.64 80.47 80.64 80.64 80.64 80.68 80.68 80.68 80.68 80.68 80.54 80.86 80.84 80.75 80.91 80.91 80.93 80.91 80.65 57.36 59.73 81.07 81.05 74.94 74.77 81.23 81.33 500 IoU (sp) 84.91 87.39 87.34 87.39 87.39 87.39 87.55 87.55 87.56 87.55 87.55 82.23 83.67 87.80 87.84 87.95 87.96 87.96 87.95 87.54 37.80 57.66 88.73 88.69 43.99 45.67 88.43 88.21 IoU (p) 77.93 82.35 82.20 82.35 82.35 82.35 82.48 82.48 82.48 82.47 82.47 77.36 79.14 82.64 82.70 82.72 82.72 82.72 82.71 82.47 36.65 52.73 83.05 82.95 41.74 42.44 82.79 82.67 MOTS 2000 IoU (sp) 82.49 82.64 80.98 82.64 82.64 82.64 82.64 82.64 82.64 82.64 82.64 80.39 82.64 82.65 82.64 83.17 83.17 83.17 83.17 83.16 83.14 83.30 83.27 83.28 83.13 83.19 83.29 83.29 IoU (p) 79.01 79.23 73.85 79.82 79.85 79.85 79.86 79.86 79.86 79.86 79.86 78.08 78.85 79.88 79.86 81.21 81.21 81.21 81.21 81.17 80.61 81.92 82.68 82.69 80.61 80.63 82.77 82.77 A more detailed description of the MCTS search process, including pseudo-code is available in Appendix B. At inference time, we use a low budget of simulations. Final actions are taken according to the constructed \u03c0MCTS(at|st). The replay-memory for both DQN and MCTS is divided into two chunks. The \ufb01rst chunk corresponds to the unary potential, while the second chunk corresponds to the overall energy function. A node is assigned to the second chunk if its associated reward is higher than the one obtained from its unary labeling. This ensures positive rewards from all the potentials during training. Every chunk is further divided into |L| categories corresponding to the |L| classes of the selected node. This guarantees a balanced sampling of the label classes in every batch during training. Beyond DQN and MCTS, we experimented with policy gradients but could not get it to work as it is an on-policy algorithm. Reusing experiences for the structured replay buffer was crucial for success of the learning algorithm. 3.6. Energy Function Finally we provide details on the energy function E given in Eq. (1). The unary potentials fi(yi) \u2208R|L| are obtained from a semantic segmentation deep net. The pairwise potential encodes smoothness and is computed as follows: fi,j(yi, yj) = \u03c8(yi, yj) \u00b7 \u03b1p \u00b7 1|gT i gj|<\u03b2p, (5) where \u03c8(yi, yj) is the label compatibility function describing the co-occurrence of two classes in adjacent locations and is given by the Potts model: \u03c8(yi, yj) = ( 1 if yi \u0338= yj 0 otherwise . (6) Moreover, |gT i gj| is the above de\ufb01ned unnormalized weight w(i, j) for the edge connecting the ith and jth nodes, i.e., superpixels. Intuitively, if the dot product between the hypercolumns gi and gj is smaller than a threshold \u03b2p and the two superpixels are labeled differently, a penalty of value \u03b1p incurs. While the pairwise term mitigates boundary errors, we address recognition errors with two detection-based higher order potentials [3]. For this purpose, we use the YoloV2 bounding box object detector [69] as it ensures a good tradeoff between speed and accuracy. Every bounding box b is presented by a tuple (lb, cb, Ib), where lb is the class label of the detected object, cb is the con\ufb01dence score of the detection and Ib \u2286{1, . . . , N} is the set of superpixels that belong to the foreground detection obtained via Grab-Cut [72]. The \ufb01rst higher order potential (HOP1) encourages superpixels within a bounding box to take the bounding box label, while enabling recovery from false detections that do not agree with other energy types. For this purpose, we add an auxiliary variable zb for every bounding box b. We use zb = 1, if the bounding box is inferred to be valid, otherwise zb = 0. Formally, f(yIb, zb) = ( wb \u00b7 cb \u00b7 P i\u2208Ib 1yi=lb if zb = 0 wb \u00b7 cb \u00b7 P i\u2208Ib 1yi\u0338=lb if zb = 1 , (7) where, wb \u2208R is a weight parameter. This potential can be simpli\ufb01ed into a sum of pairwise potentials between zb and each yi with i \u2208Ib, i.e., f(yIb, zb) = P i\u2208Ib fi,b(yi, zb), where: fi,b(yi, zb) = ( wb \u00b7 cb \u00b7 1yi=lb if zb = 0 wb \u00b7 cb \u00b7 1yi\u0338=lb if zb = 1 . (8) This simpli\ufb01cation enables solving the higher order potential using traditional techniques like mean \ufb01eld inference [3]. To show the merit of the RL framework, we introduce another higher order potential (HOP2) that can not be seamlessly reduced to a pairwise one: f(yIb) = \u03bbb \u00b7 1(P i\u2208Ib yi=l)< |Ib| C , (9) with \u03bbb and C being scalar parameters. This potential is evaluated for bounding boxes with special characteristics to encourage the superpixels in the bounding box to be of label l. Intuitively, if the number of superpixels i \u2208Ib having label l is less than a threshold |Ib| C , a penalty \u03bbb incurs. For Pascal VOC, we evaluate the potential on bounding boxes b included in larger bounding boxes, as we noticed that the unaries frequently miss small objects overlapping with other larger objects in the image (l = lb). For MOTS, we evaluate this potential on bounding boxes of type \u2018pedestrians\u2019 overlapping with bounding boxes of type \u2018bicycle.\u2019 As cyclists \fFigure 3: Success cases. should not be labeled as pedestrians, we set l to be the background class. Transforming this term into a pairwise one to enable using traditional inference techniques requires an exponential number of auxiliary variables. 4. Experiments In the following, we evaluate our learning based inference algorithm on Pascal VOC [19] and MOTS [19] datasets. The original Pascal VOC dataset contains 1464 training and 1449 validation images. In addition to this data, we make use of the annotations provided by [29], resulting in a total of 10582 training instances. The number of classes is 21. MOTS is a multi-object tracking and segmentation dataset for cars and pedestrians (2 classes). It consists of 12 training sequences (5027 frames) and 9 validation ones (2981 frames). In this work, we perform semantic segmentation at the level of superpixels, generated using SLIC [84]. Every superpixel corresponds to a node i in the graph as illustrated in Fig. 1. The unary potentials at the pixel level are obtained from PSPNet [94] for Pascal VOC and TrackR-CNN [86] for MOTS. The superpixels\u2019 unaries are the average of the unaries of all the pixels that belong to that superpixel. The higher order potential is based on the YoloV2 [69] bounding box detector. Additional training and implementation details are described in Appendix A. Evaluation Metrics: As evaluation metrics, we use intersection over union (IoU) computed at the level of both superpixels (sp) and pixels (p). IoU (p) is obtained after mapping the superpixel level labels to the corresponding set of pixels. Baselines: We compare our results to the segmentations obtained by \ufb01ve different solvers from three categories: (1) message passing algorithms, i.e., Belief propagation (BP) [64] and Tree-reweighted Belief Propagation (TBP) [87], (2) a Lagrangian relaxation method, i.e., Dual Decomposition Subgradient (DD) [37], and (3) move making algorithms, i.e., Lazy Flipper (LFlip) [1] and \u03b1-expansion as implemented in [20]. Note that these solvers can not optimize our HOP2 potential. Besides, we train a supervised model that predicts the node label from the provided node features. Performance Evaluation: We show the results of solving the program given in Eq. (1) in Tab. 2, for unary (Col. 5), unary plus pairwise (Col. 6), unary plus pairwise plus HOP1 (Col. 7) and unary plus pairwise plus HOP1 and HOP2 (Col. 8) potentials. For every potential type, we report results on graphs with superpixel numbers 50, 250 and 500 for Pascal VOC and 2000 for MOTS, obtained from DQN and MCTS, trained each with the two reward schemes discussed in Sec. 3.5. Since MOTS has small objects, we opt for a higher number of superpixels. It is remarkable to observe that DQN and MCTS are able to learn heuristics which outperform the baselines. Interestingly, the policy has learned to produce better semantic segmentations than the ones obtained via MRF energy minimization. Guided by a reward derived just from the energy function, the graph neural network (the policy) learns characteristic node embeddings for every semantic class by leveraging the hypercolumn and bounding box features as well as the neighborhood characteristics. The supervised baseline shows low performance, which proves the merit of the learned policies. Overall MCTS performance is comparable to the DQN one. This is mainly due to the learned policies being somewhat local and focusing on object boundaries, not necessitating a large multi-step look-ahead, as we will show in the following. In Fig. 3, we report success cases of the RL algorithms. Smoothness modeled by our energy \ufb01xed the bottle segmentation in the \ufb01rst image. Furthermore, our model detects missing parts of the table in the second image in the \ufb01rst row and a car in the image in the second row, that were missed by the unaries. Also, we show that we \ufb01x a mis-labeling of a truck as a car in the image in the third row. Flexibility of Potentials: In Fig. 4, we show examples of improved segmentations when using the pairwise, HOP1 and HOP2 potentials respectively. The motorcycle driver segmentation improved incrementally with every potential (\ufb01rst image) and the cyclist is not detected anymore as a pedestrian (second image). Generalization and scalability: The graph embedding network enables training and testing on graphs with different number of nodes, since the same parameters are used. We investigate how models trained on graphs with few nodes \fFigure 4: Output of our method for different potentials. Table 3: Generalization of the learned policy. PSPNet 500 1000 2000 10000 Pascal VOC DQN MCTS DQN MCTS DQN MCTS DQN MCTS IoU (sp) \u2212 88.74 88.73 87.58 87.61 86.36 86.39 84.66 84.67 IoU (p) 82.61 83.06 83.01 83.71 83.73 83.74 83.78 83.80 83.82 TrackR-CNN 5000 10000 DQN MCTS DQN MCTS MOTS IoU (sp) \u2212 79.81 79.80 76.73 76.69 IoU (p) 84.98 83.49 83.46 84.69 84.63 Table 4: Run-time during inference in seconds for Pascal VOC dataset. Nodes U+P U+P+HOP1 U+P+HOP1 +HOP2 BP TBP DD L-Flip \u03b1-Exp DQN MCTS BP TBP DD L-Flip \u03b1-Exp DQN MCTS DQN MCTS 50 0.14 0.52 0.28 0.12 0.01 0.04 0.20 0.15 0.62 0.31 0.187 0.01 0.04 0.23 0.04 0.24 250 1.56 2.13 1.26 0.53 0.04 0.22 2.22 1.70 2.77 1.65 0.59 0.07 0.22 2.89 0.22 3.01 500 3.26 4.76 2.82 1.07 0.12 0.52 7.27 3.37 5.37 3.70 0.97 0.22 0.53 9.17 0.52 9.69 1000 6.63 9.65 6.84 1.80 0.30 0.78 18.5 7.22 10.4 7.47 2.25 0.36 0.78 21.6 0.78 22.8 2000 12.3 19.9 14.8 3.57 0.70 1.70 38.3 12.7 23.9 15.1 4.47 0.72 1.70 43.2 1.72 46.2 10000 72.8 130.9 143.7 22.6 4.81 8.23 202.1 88.7 140.1 106.9 23.5 4.72 8.25 209.7 8.20 210.3 perform on larger graphs. As shown in Tab. 3, compelling accuracy and IoU values for generalization to graphs with up to 500, 1000, 2000, and 10000 nodes are observed when using a policy trained on graphs of 250 nodes for Pascal VOC, and to graphs with up to 5000 and 10000 nodes when using a policy trained on 2000 nodes for MOTS. Here, we consider the energy consisting of the combined potentials (unary, pairwise, HOP1 and HOP2). Note that we outperform PSPNet at the pixel level for Pascal VOC. Runtime ef\ufb01ciency: In Tab. 4, we show the inference runtime for respectively the baselines, DQN and MCTS. The runtime scales linearly with the number of nodes and does not even depend on the potential type/order in case of DQN, as inference is reduced to a forward pass of the policy network at every iteration (Fig. 9). DQN is faster than all the solvers apart from \u03b1-exp. However, performance-wise, \u03b1expansion has worse results (Tab. 2). MCTS is slower as it performs multiple simulations per node and requires computation of the reward at every step. Learned Policies: In Fig. 5, we show the probability map across consecutive time steps. The selected nodes are colored in white. The darker the superpixel, the smaller the probability of selecting it next. We found that the heuristic learns a notion of smoothness, choosing nodes that are in close proximity and of the same label as the selected ones. Also, the policy learns to start labeling the nodes with low unary distribution entropy \ufb01rst, then decides on the ones with higher entropy. Figure 5: Visualization of the learned policy. Figure 6: Failure cases. Limitations: Our method is based on super-pixels, hence datasets with small objects require a large number of nodes and a longer run-time (MOTS vs. Pascal VOC). Also, our method is sensitive to bounding box class errors, as illustrated in Fig. 6 (\ufb01rst example), and to the parameters calibration of the energy function, as shown in the second example of the same \ufb01gure. We plan to address the latter concern in future work via end-to-end training. Furthermore, little is know about deep reinforcement learning convergence. Nevertheless, it has been successfully applied to solve combinatorial programs by leveraging the structure in the data. We show that in our case as well, it converges to reasonable policies. 5."
+                }
+            ],
+            "Alexander G. Schwing": [
+                {
+                    "url": "http://arxiv.org/abs/1503.02351v1",
+                    "title": "Fully Connected Deep Structured Networks",
+                    "abstract": "Convolutional neural networks with many layers have recently been shown to\nachieve excellent results on many high-level tasks such as image\nclassification, object detection and more recently also semantic segmentation.\nParticularly for semantic segmentation, a two-stage procedure is often\nemployed. Hereby, convolutional networks are trained to provide good local\npixel-wise features for the second step being traditionally a more global\ngraphical model. In this work we unify this two-stage process into a single\njoint training algorithm. We demonstrate our method on the semantic image\nsegmentation task and show encouraging results on the challenging PASCAL VOC\n2012 dataset.",
+                    "authors": "Alexander G. Schwing, Raquel Urtasun",
+                    "published": "2015-03-09",
+                    "updated": "2015-03-09",
+                    "primary_cat": "cs.CV",
+                    "cats": [
+                        "cs.CV",
+                        "cs.LG"
+                    ],
+                    "main_content": "Introduction In the past few years, Convolutional Neural Networks (CNNs) have revolutionized computer vision. They have been shown to achieve state-of-the-art performance in a variety of vision problems, including image classi\ufb01cation [19, 31], object detection [11], human pose estimation [32], stereo [36], and caption generation [15, 24, 35, 8, 14, 10]. This is mainly due to their high representational power achieved by learning complex, non-linear dependencies. It is only very recently that convolutional nets have proven also very effective for semantic segmentation [12, 30, 21, 41, 3]. This is perhaps due to the fact that to achieve invariance, pooling operations are performed, often reducing the dimensionality of the prediction. A Markov random \ufb01eld (MRF) is then used as a re\ufb01nement step in order to obtain segmentations that respect well segment boundaries. The seminal work of [17] showed that inference in fully connected MRFs is possible if the smoothness potentials are Gaussian. Impressive performance was demonstrated in semantic segmentation with hand craft features. Later, [3] extended the unary potentials to incorporate convolutional network features. However, these current approaches train the segmentation models in a piece-wise fashion, \ufb01xing the unary weights during learning of the parameters of the pairwise terms which enforce smoothness. In this paper we present an algorithm that is able to train jointly the parameters of the convolutional network de\ufb01ning the unary potentials as well as the smoothness terms taking into account the dependencies between the random variables. We demonstrate the effectiveness of our approach using the dataset of the PASCAL VOC 2012 challenge [9]. 2 Background We begin by describing how to learn probabilistic deep networks which take into account correlations between multiple output variables y = (y1, . . . , yN) that are of interest to us. Moreover, a valid con\ufb01guration y \u2208Y = QN i=1 Yi is assumed to lie in the product space of the discrete variable domains Yi = {1, . . . |Yi|}. For a given data sample x \u2208X, and a parameter vector w \u2208RA, the score F of a con\ufb01guration y \u2208Y is generally modeled by the mapping F : X \u00d7 Y \u00d7 RA \u2192R. 1 arXiv:1503.02351v1  [cs.CV]  9 Mar 2015 \fAlgorithm: Deep Learning Repeat until stopping criteria 1. Forward pass to compute F(x, \u02c6 y; w) \u2200\u02c6 y \u2208Y 2. Normalization via soft-max to obtain p(\u02c6 y | x, w) 3. Backward pass through de\ufb01nition of function via chain rule 4. Parameter update Figure 1: Gradient descent for learning deep models. The prediction task amounts to \ufb01nding the con\ufb01guration y\u2217= arg max \u02c6 y\u2208Y F(x, \u02c6 y; w), (1) which maximizes the score F(x, \u02c6 y; w). Note that the best scoring con\ufb01guration y\u2217is equivalently given as the maximizer of the probability distribution p(\u02c6 y | x, w) \u221dexp F(x, \u02c6 y; w), since the exponential function is a monotone increasing function and the normalization constant is independent of the con\ufb01guration \u02c6 y \u2208Y, i.e., it is constant indeed. The learning task is concerned with \ufb01nding a parameter vector w\u2217= arg max w\u2208RA Y (x,y)\u2208D p(y | x, w), (2) which maximizes the likelihood of a given training set D = {(x, y)}. The training set consists of input-output pairs (x, y) which are assumed to be independent and identically distributed. Note that maximizing the likelihood is equivalent to maximizing the cross entropy between the modeled distribution p(\u02c6 y | x, w) and a target distribution which places all its mass on the groundtruth con\ufb01guration y. Throughout this work we make no further assumptions about the dependence of the scoring function F(x, \u02c6 y; w) on the parameter vector w, i.e., F(x, \u02c6 y; w) is generally neither convex nor smooth. For problems where the output-space size |Y| = QN i=1 |Yi| is in the thousands, we can exactly solve the inference task given in Eq. (1) by searching over all possible output space con\ufb01gurations \u02c6 y \u2208Y. In such a setting, those different con\ufb01gurations are typically referred to as different classes. Similarly, we normalize the distribution p(\u02c6 y | x, w) by summing up the exponentiated score exp F(x, \u02c6 y; w) over all possibilities \u02c6 y \u2208Y. This is often referred to as a soft-max computation. Non-convexity and non-smoothness of the learning objective w.r.t. the parameters w is answered with stochastic gradient ascent. For ef\ufb01ciency, the gradient is often computed on a small subset of the training data, i.e., a mini-batch. We summarize the resulting training algorithm in Fig. 1. On a high level it consists of four steps which are iterated until a stopping criterion is met: (i) the forward pass to compute the scoring function F(x, \u02c6 y; w) for all output space con\ufb01gurations \u02c6 y \u2208Y. (ii) normalizing the scoring function via a soft-max computation to obtain the probability distribution p(\u02c6 y | x, w). (iii) computation and back-propagation of the gradient of the loss function, i.e., often the log-likelihood or equivalently the cross-entropy. (iv) an update of the parameters. However, solving the inference task given in Eq. (1) or the learning problem stated in Eq. (2) is computationally challenging if we consider more complex output spaces Y, e.g., those arising from tasks like image tagging. The situation is even more severe if we target image segmentation where the exponential number of possible output space con\ufb01gurations prevents even storage of F(x, \u02c6 y; w) \u2200\u02c6 y \u2208Y. Note that this is required in the \ufb01rst line of the algorithm summarized in Fig. 1. Given an exponential amount of possible con\ufb01gurations |Y| = QN i=1 |Yi|, how do we represent the scoring function F(x, \u02c6 y; w) ef\ufb01ciently? Assuming we have an ef\ufb01cient representation, how can we effectively normalize the probability p(\u02c6 y | x, w)? One possible answer to those questions was given by Chen et al. [4], who discussed extending log-linear models, i.e., those with a scoring function of 2 \fAlgorithm: Learning Deep Structured Models Repeat until stopping criteria 1. Forward pass to compute fr(x, \u02c6 yr; w) \u2200r \u2208R, \u02c6 yr \u2208Yr 2. Computation of marginals b(x,y),r(\u02c6 yr) via loopy belief propagation, convex belief propagation or tree-reweighted message passing 3. Backward pass through de\ufb01nition of function via chain rule 4. Parameter update Figure 2: Approximated gradient descent for learning deep structured models. the form F(x, \u02c6 y; w) = w\u22a4\u03c6(x, \u02c6 y), to the more general setting, i.e., an arbitrary dependence of the scoring function F(x, \u02c6 y; w) on the parameter vector w. In short, [4] assumed the global scoring function F(x, \u02c6 y; w) to decompose into a sum of local scoring functions fr, each depending on a small subset r \u2286{1, . . . , N} of variables \u02c6 yr = (\u02c6 yi)i\u2208r. All restrictions r required to compute the global function via F(x, \u02c6 y; w) = X r\u2208R fr(x, \u02c6 yr; w) (3) are subsumed in the set R. If the size of each and every local restriction set r \u2208R is small, F(x, \u02c6 y; w) is ef\ufb01ciently representable. To compute the gradient of the log-likelihood cost function, we require a properly normalized distribution p(\u02c6 y | x, w), or more speci\ufb01cally its marginals b(x,y),r(\u02c6 yr) for each restriction r \u2208R. To this end, message passing type algorithms were employed by [4]. Such an approach is exact if the distribution p(\u02c6 y | x, w) is of low tree-width. Otherwise computational complexity is prohibitively large and approximations like loopy belief propagation [26], convex belief propagation [39] or treereweighted message passing [37] are alternatives that were successfully applied. The resulting iterative method of [4] is summarized in Fig. 2. In a \ufb01rst step the forward pass computes all outputs of every local scoring function. Afterwards (approximate) marginals are obtained in a second step, and utilized to compute the derivative of the (approximated) maximum likelihood cost function w.r.t. the parameters w. The following backward pass computes the gradient of the parameters by repeatedly applying the chain-rule according to the de\ufb01nition of the scoring function F(x, \u02c6 y; w). The gradient is then utilized during the \ufb01nal parameter update. Not only does the approach presented by [4] fail if the decomposition assumed in Eq. (3) is not available. But it is also computationally challenging to obtain the required marginals if too many local functions are required. I.e., computation is slow if the number of restrictions |R| is large, e.g., when working with densely connected image segmentation models where every pixel is possibly correlated to every other pixel in the image. 3 Approach Densely connected models were previously considered by [17, 33, 34, 18] and shown to yield impressive results for the image segmentation task. Learning the parameters of densely connected models was considered by Kr\u00a8 ahenb\u00a8 uhl and Koltun [18] in the context of the log-linear setting. Following [4] we aim at extending those fully connected log-linear models to the more general setting of an arbitrary function F(x, \u02c6 y; w), e.g., a deep convolutional neural network. Note that a similar approach has been recently discussed by [41] in independent work. Let us consider within this section how to ef\ufb01ciently combine deep structured prediction [4] with densely connected probabilistic models [17, 33, 34, 18]. Before getting into the details we note that the presented approach trades computational complexity of the general method of [4] with a restriction on the pairwise functions fij (i.e., r = {i, j}). Concretely, the local functions fij are assumed to be mixtures of kernels in a feature space as detailed below. For simplicity we assume that local functions of order higher than two are not required to represent our global scoring function F(x, \u02c6 y; w). Generalizations have however been presented, e.g., by Vineet et al. [34]. 3 \f3.1 Inference We begin our discussion by considering the inference task. To obtain a computationally ef\ufb01cient prediction algorithm we use a mean \ufb01eld approximation of the model distribution p(\u02c6 y | x, w) for every sample (x, y). More formally, we assume our approximation to factor according to q(x,y)(\u02c6 y) = QN i=1 q(x,y),i(\u02c6 yi). Given some parameters w, we employ a forward pass to obtain our local function representations fr(x, \u02c6 yr; w). Next we compute the single variable marginals q(x,y),i(\u02c6 yi) by minimizing the Kullback-Leibler (KL) divergence w.r.t. to the assumed factorization of the mean \ufb01eld distribution q(x,y)(\u02c6 y), i.e., q\u2217 (x,y) = arg min q\u2208\u2206DKL(q(x,y)(\u02c6 y)||p(\u02c6 y | x, w)). (4) Hereby q \u2208\u2206requires q to be a valid probability distribution. Due to non-convexity, only convergence to a stationary point of the KL divergence cost function is guaranteed for sequential block-coordinate updates [38, 16]. More precisely, iterating until convergence through the variables i \u2208{1, . . . , N} using the closed form update q(x,y),i(\u02c6 yi) \u221dexp \uf8eb \uf8edfi(\u02c6 yi, x, w) + X j\u2208N (i),\u02c6 yj fij(\u02c6 yi, \u02c6 yj, x, w)q(x,y),j(\u02c6 yj) \uf8f6 \uf8f8, (5) which assumes all marginals but q(x,y),i to be \ufb01xed, retrieves a stationary point for the cost function of the program given in Eq. (4). The set of variables neighboring i is denoted N(i). In the case of densely connected variables, the computational bottleneck arises from the second summand which involves P j\u2208N (i) |Yj| additions. The sum ranges over |N(i)| = N \u22121 terms for densely connected structured models. Hence the complexity of an update for a single marginal is of O(N), and updating all N marginals therefore requires O(N 2) operations as also discussed by Kr\u00a8 ahenb\u00a8 uhl and Koltun [18]. Importantly, Kr\u00a8 ahenb\u00a8 uhl and Koltun [17] observed that a high dimensional Gaussian \ufb01lter can be applied to concurrently update all marginals in O(N). This is achievable when constraining ourselves to pairwise functions being mixtures of M kernels in the feature space as mentioned before. Formally, we require fij(\u02c6 yi, \u02c6 yj, x, w) = M X m=1 \u00b5(m)(\u02c6 yi, \u02c6 yj, w)k(m)( \u02c6 fi(x) \u2212\u02c6 fj(x)), where \u00b5(m) is a label compatibility function, k(m) is a kernel function, and \u02c6 fi(x) are features of variable i depending on the data x. However, to ensure convergence to a stationary point of the KL divergence cost function for this parallel update, further restrictions on the form of the pairwise functions fij apply. Formally, if the label compatibility functions \u00b5(m) are negative semi-de\ufb01nite \u2200m, and the kernels k(m) are positive de\ufb01nite \u2200m, the KL divergence is readily given as the difference between a concave and a convex term [18]. Hence the concave-convex procedure (CCCP) [40] is directly applicable. We therefore proceed iteratively by \ufb01rst linearizing the concave term at the current location and second minimizing the resulting linearized but convex program. As detailed by Kr\u00a8 ahenb\u00a8 uhl and Koltun [18], and as discussed above, \ufb01nding the linearization is equivalently solved via \ufb01ltering in time linear in N. Solving the convex program in its original form requires solving a non-linear system of equations independently for each marginal q(x,y),i(\u02c6 yi), e.g., via Newton\u2019s method. A further approximation to the cross-entropy term of the KL-divergence relates the ef\ufb01cient \ufb01ltering based mean \ufb01eld update of the marginals q(x,y),i(\u02c6 yi) to the corresponding cost function for which a stationary point is found. 3.2 Learning Having observed that mean-\ufb01eld inference can be ef\ufb01ciently addressed with Gaussian \ufb01ltering, given restrictions on the pairwise functions fij, we now turn our attention to the learning task. As mentioned before we aim at \ufb01nding a parameter vector w that maximizes the likelihood objective function. Since the exact likelihood is computationally expensive, we use the log-likelihood based on 4 \fAlgorithm: Learning Fully Connected Deep Structured Models Repeat until stopping criteria 1. Forward pass to compute fr(x, \u02c6 yr; w) \u2200r \u2208R, yr \u2208Yr 2. Computation of marginals qt (x,y),i(\u02c6 yi) via \ufb01ltering for t \u2208{1, . . . , T} 3. Backtracking through the marginals qt (x,y),i(\u02c6 yi) from t = T \u22121 down to t = 1 4. Backward pass through de\ufb01nition of function via chain rule 5. Parameter update Figure 3: Stochastic gradient descent for learning fully connected deep structured models. the mean-\ufb01eld marginals. Hence our surrogate loss function L(x,y) for a sample (x, y) with corresponding annotated ground truth labeling y is given by L(x,y)(q(x,y)) = \u2212 N X i=1 log q(x,y),i(yi). (6) To perform a parameter update step we need the gradient of the surrogate loss function w.r.t. the parameters, i.e., \u2202L(x,y) \u2202w = \u2202L(x,y) \u2202q(x,y) \u00b7 \u2202q(x,y) \u2202w . (7) The gradient of the surrogate loss function L(x,y) w.r.t. the marginals is easily obtained from Eq. (6). It is given by \u2202L(x,y) \u2202q(x,y),i(\u02c6 yi) = \u2212 1 q(x,y),i(yi)J\u02c6 yi = yiK, (8) where the Iverson bracket J\u02c6 yi = yiK equals one if \u02c6 yi = yi, and returns zero otherwise. To perform a gradient step during learning, we additionally require the derivatives of the marginals w.r.t. the parameters, i.e., \u2202q(x,y),i(\u02c6 yi) \u2202w . More carefully investigating the mean-\ufb01eld update given in Eq. (5) reveals a recursive de\ufb01nition. More concretely, the derivative \u2202qt (x,y),i(\u02c6 yi) \u2202w of the marginal qt (x,y),i(\u02c6 yi) after t iterations depends on the results from earlier iterations. Hence, we obtain the desired result by successively back-tracking through the mean-\ufb01eld iterations from the last iteration back to the \ufb01rst. This direct computation is however computationally expensive. Fortunately, back-substitution into the loss gradient yields an algorithm which requires a total of T back-tracking steps, independent of the number of parameters. We refer the interested reader to [18] for additional details regarding the computation of the gradient \u2202q(x,y),i(\u02c6 yi) \u2202w . But contrasting [18], we no longer assume the unaries to be given by a logistic regression model. Contrasting [3], we don\u2019t assume the unaries to be \ufb01xed during CRF parameter updates. Generalizing the gradient of the marginals w.r.t. parameters to arbitrary unaries is straightforward since the gradients are directly given by the marginals. Combined with the gradient of the log-likelihood loss function w.r.t. the marginals, given in Eq. (8), we obtain \u2202L(x,y) \u2202w as the difference between the ground-truth and the predicted marginals. This result is then used for back-propagation through any functional structure which provides the unary scoring functions fi, e.g., convolutional neural networks. Derivatives w.r.t. to label compatibility and kernel shape parameters are readily given in [18]. The resulting algorithm is summarized in Fig. 3. In short, we \ufb01rst obtain again our functional representation via a forward pass through any functional network. Subsequently we compute our mean\ufb01eld marginals via \ufb01ltering. Afterwards we obtain the gradient of the loss function via an ef\ufb01cient back-tracking. In the next step the gradient of the parameters is computed by back-propagating the gradient of the loss-function using the chain-rule dictated by the de\ufb01nition of the scoring function. In a \ufb01nal step we update the parameters. 5 \f2000 3000 4000 5000 58 59 60 61 62 Iterations Validation set accuracy 0 500 1000 60 65 70 75 Iterations Accuracy     Training set Validation set Unary only (a) (b) Figure 4: (a) Validation set performance over the number of iterations when \ufb01ne-tuning the unary parameters only. (b) Validation set performance over the number of iterations when \ufb01ne-tuning all parameters. 4 Experiments We evaluate our approach summarized in Fig. 3 on the dataset of the Pascal VOC 2012 challenge [9]. The task is semantic image segmentation of 21 object classes (including background). The original dataset contains 1464 training, 1449 validation and 1456 test images. In addition to this data we make use of the annotations provided by Hariharan et al. [13], resulting in a total of 10582 training instances. The reported performance is measured using the intersection-over-union metric. Note that we conduct our tests on the 1449 validation set images which were neither used during training nor for \ufb01ne-tuning. 4.1 Model Our model setup follows [3], i.e., we employ the 16 layer DeepNet model [31]. Just like [3] we \ufb01rst convert the fully connected layers into convolutions as \ufb01rst discussed in [12, 30]. This is useful since we are not interested in a single variable output prediction, but rather aim at learning probability masks. To obtain a larger probability mask we skip downsampling during the last two max-pooling operations. To take into account the skipped downsampling during subsequent convolutions we employ the \u2018` a trous (with hole) algorithm\u2019 [23]. It takes care of the fact that data is stored in an interleaved way, i.e., in our case convolutions sub-sample the input data by a factor of two or four respectively. To adapt to the 21 object classes we also replace the top layer of the DeepNet model to yield 21 classes for each pixel. Similar to [3] we assume the input size of our network to be of dimension 306 \u00d7 306 which results in a 40\u00d740 sized spatial output of the DeepNet which is in our case an intermediate result however. Contrasting [3], we jointly optimize for both unary and CRF parameters using the algorithm presented in Fig. 3. To this end, given images downsampled to a size of 306 \u00d7 306, our algorithm \ufb01rst performs a forward pass through the convolutional DeepNet to obtain the 40 \u00d7 40 \u00d7 21 sized class probability maps in an intermediate stage. These intermediate class probability maps are directly up-sampled to the original image dimension using a bi-linear interpolation layer. This yields the actual output of our augmented DeepNet network de\ufb01ning the scoring function F(x, \u02c6 y, w). Note that the number N of variables \u02c6 y = (\u02c6 y1, . . . , \u02c6 yN) \u2208Y is therefore equal to the number of pixels of the original image. For the second step of our algorithm we perform 5 iterations of mean \ufb01eld updates to compute the marginals q(x,y),i(\u02c6 yi) of the fully connected CRF. Those are then compared to the original groundtruth image segmentations, using as our loss function the sum of cross-entropy terms, i.e., the log-likelihood loss, as speci\ufb01ed in Eq. (6). In the third step we back-track through the marginals to obtain a gradient of the loss function. Afterwards we back-propagate the derivatives w.r.t. the unary term through both the bi-linear interpolation and the 16-layer convolutional network. The shape and compatibility parameters of the CRF, detailed below, are updated directly. 6 \fData bkg areo bike bird boat bottle bus car cat chair cow Valid. 90.461 77.455 30.355 76.564 60.735 65.075 81.261 74.958 81.505 23.367 66.279 Train 90.159 76.314 64.450 78.677 68.224 68.044 84.491 80.274 86.347 44.567 79.987 Data table dog horse mbike person plant sheep sofa train tv Our mean [3] Valid. 52.219 70.624 66.660 65.725 72.913 42.174 73.452 43.412 71.738 58.322 64.060 63.74 Train 62.710 82.987 76.729 76.523 75.399 63.863 79.937 55.146 80.699 70.164 73.604 Table 1: Performance of our approach for individual classes. In the last two columns of the lower panel we compare our mean to the recently presented baseline by Chen et al. [3]. It was shown independently by many authors [31, 4], that successively increasing the number of parameters during training typically yields better performance due to better initialization of larger models. We therefore train our model in two stages. First, we assume no pairwise connections to be present, i.e., we \ufb01ne-tune the weights obtained from the DeepNet ImageNet model [31, 29] to the Pascal dataset [9]. Standard parameter settings for a momentum of 0.9, a weight decay of 0.0005 and learning rates of 0.01 and 0.001 for the top and all other layers are employed respectively. Due to the 12GB memory restrictions on the Tesla K40 GPU we use a mini-batch size of 20 images. In a second stage we jointly train the convolutional network parameters as well as the compatibility and shape parameters of the dense CRF arising from the pairwise functions fij(\u02c6 yi, \u02c6 yj, x, w) = \u00b5(\u02c6 yi, \u02c6 yj) 2 X m=1 wmk(m)( \u02c6 f (m) i (x) \u2212\u02c6 f (m) j (x)). (9) Hereby, we employ the Potts potential \u00b5(yi, yj) = Jyi = yjK and the Gaussian kernels given by k(m) = exp \u0012 \u22121 2(f (m) i \u2212f (m) i )\u22a4\u03a3\u22121 m ( \u02c6 f (m) i \u2212\u02c6 f (m) i ) \u0013 . As indicated in Eq. (9), we use M = 2 kernels, both with diagonal covariance matrix \u03a3m. One containing as features \u02c6 fi(x) the two-dimensional pixel positions, the other one containing as features the two dimensional pixel positions as well as the three color channels. Hence we obtain a total of nine parameters, i.e., two compatibility parameters w1 and w2 and 2+5 = 7 kernel shape parameters for the diagonal covariance matrices \u03a3m. 4.2 Results As mentioned before, all our results were computed on the validation set of the Pascal VOC dataset. This part of the data was neither used for training nor for \ufb01ne-tuning. Unary performance: We \ufb01rst investigate the performance of the \ufb01rst training stage of the proposed approach, i.e., \ufb01ne-tuning of the 16 layer DeepNet parameters on the Pascal VOC data. The validation set accuracy is plotted over the number of iterations in Fig. 4 (a). We observe the performance to peak at around 4000 iterations with a mean intersection over union measure of 61.476%. The result reported by [3] for this experiment is 59.80%, i.e., we outperform their unary model by 1.5%. Joint training: Next we illustrate the performance of the second step, i.e., joint training of both convolutional network parameters and CRF compatibility and shape parameters. In Fig. 4 (b) we indicate the best obtained unary performance from the \ufb01rst step and visualize the validation and training set performance over the number of iterations. We observe the results to peak quickly after around 20 iterations and remain largely stable thereafter. Details: In Tab. 1 we provide the training and test set accuracies for the 21 individual classes. We observe the \u2018bike\u2019 and \u2018chair\u2019 class to be particularly dif\ufb01cult. For both categories the validation set performance is roughly half of the training set accuracy. Comparison to baseline: As provided in Tab. 1, the peak validation set performance of our approach is 64.060%, which slightly outperforms the separate training result of 63.74% reported by Chen et al. [3]. 7 \fFigure 5: Visual results of good predictions. Visual results: We illustrate visual results of our approach in Fig. 5. Our method successfully segments the object if the images are clearly apparent. Noisy images and objects with many variations pose challenges to the presented approach as visualized in Fig. 6. Also, we observe our learnt parameters to generally over-smooth results while being noisy on the boundaries. 5 Discussion We presented a \ufb01rst method that jointly trains convolutional neural networks and fully connected conditional random \ufb01elds for semantic image segmentation. To this end we generalize [3] to joint training. Note that a method along those lines has also been recently made publicly available in independent work [41]. Whereas the latter combines dense conditional random \ufb01elds [17] with the fully convolutional networks presented by Long et al. [21], we employ and modify the 16 layer DeepNet architecture presented in work by Simonyan and Zisserman [31]. Ideas along the lines of joint training were discussed within machine learning and computer vision as early as the 90\u2019s in work done by Bridle [2] and Bottou [1]. More recently [5, 27, 22, 6, 28, 25] incorporate non-linearities into unary potentials but generally assume exact inference to be tractable. Even more recently, Li and Zemel [20] investigate training with hinge-loss objectives using nonlinear unaries, but the pairwise potentials remain \ufb01xed, i.e., no joint training. Domke [7] decomposes the learning objective into logistic regressors which will be computationally expensive in our setting. Tompson et al. [32] propose joint training for pose estimation based on a heuristic approximation which ignores the normalization constant of the model distribution. Joint training of conditional random \ufb01elds and deep networks was also discussed recently by [4] for graphical models in general. Techniques based on convex and non-convex approximations were described for obtaining marginals in the general non-linear setting. 8 \fFigure 6: Failure cases 6"
+                }
+            ],
+            "Zhenghai Xue": [
+                {
+                    "url": "http://arxiv.org/abs/2306.03552v4",
+                    "title": "State Regularized Policy Optimization on Data with Dynamics Shift",
+                    "abstract": "In many real-world scenarios, Reinforcement Learning (RL) algorithms are\ntrained on data with dynamics shift, i.e., with different underlying\nenvironment dynamics. A majority of current methods address such issue by\ntraining context encoders to identify environment parameters. Data with\ndynamics shift are separated according to their environment parameters to train\nthe corresponding policy. However, these methods can be sample inefficient as\ndata are used \\textit{ad hoc}, and policies trained for one dynamics cannot\nbenefit from data collected in all other environments with different dynamics.\nIn this paper, we find that in many environments with similar structures and\ndifferent dynamics, optimal policies have similar stationary state\ndistributions. We exploit such property and learn the stationary state\ndistribution from data with dynamics shift for efficient data reuse. Such\ndistribution is used to regularize the policy trained in a new environment,\nleading to the SRPO (\\textbf{S}tate \\textbf{R}egularized \\textbf{P}olicy\n\\textbf{O}ptimization) algorithm. To conduct theoretical analyses, the\nintuition of similar environment structures is characterized by the notion of\nhomomorphous MDPs. We then demonstrate a lower-bound performance guarantee on\npolicies regularized by the stationary state distribution. In practice, SRPO\ncan be an add-on module to context-based algorithms in both online and offline\nRL settings. Experimental results show that SRPO can make several context-based\nalgorithms far more data efficient and significantly improve their overall\nperformance.",
+                    "authors": "Zhenghai Xue, Qingpeng Cai, Shuchang Liu, Dong Zheng, Peng Jiang, Kun Gai, Bo An",
+                    "published": "2023-06-06",
+                    "updated": "2024-02-22",
+                    "primary_cat": "cs.LG",
+                    "cats": [
+                        "cs.LG",
+                        "cs.AI"
+                    ],
+                    "main_content": "Introduction Reinforcement Learning (RL) has achieved great success in solving challenging sequential decisionmaking problems [1, 2]. Unfortunately, existing RL methods usually assume that agents are trained and evaluated in exactly the same environment, which is often not the case in real-world applications where environment dynamics can vary a lot. For example, the recommendation engine of social apps may need to deal with time-varying and heterogeneous user preferences [3, 4]. A robot arm may operate in different scenarios with different joint frictions and medium densities [5]. In these cases, the agent has to work with the trajectory data from different environment dynamics, i.e., data with dynamics shift, which will bias the learning process and lead to poor performance. In fact, some empirical studies [6, 5] demonstrate that general RL algorithms [7, 8] can easily be misled by different environment dynamics and fail to train a good policy. In recent years, considerable research efforts have been devoted to addressing the dynamics shift and learning generalizable policies for environments with changing dynamics. One common practice is to train a context encoder [9, 10, 11] to associate the environment dynamics with a latent variable. The policy is then trained with the latent variable as an additional input [12]. One issue with this 37th Conference on Neural Information Processing Systems (NeurIPS 2023). arXiv:2306.03552v4  [cs.LG]  22 Feb 2024 \f1 3 5 Number of Different Dynamics 0 1 2 3 4 Return \u00d7102 Performance in Ant Environment Algorithm PPO CaDM CaDM+SRPO Figure 1: Performance comparison of PPO [7], CaDM [9] and CaDM+SRPO in the Ant environment, where SRPO is our proposed state regularized policy optimization method. Details of the experiment setup are in Sec. 5.1. practice is that policies conditioned on a specific latent variable can only learn from data collected in the environment corresponding to that latent variable. In other words, data with different dynamics are used in an ad hoc manner. The generalizability of context encoders relies on the expressive power of neural networks. However, neural networks are prone to overfit and behave poorly when extrapolating. As an example, we benchmarked CaDM [9], which is one of the context-based algorithms, under Ant environments with different gravities and display the results in Fig. 1. Although it can outperform PPO [7] due to its adaptability from context encoders, CaDM fails to constantly improve its performance with more data from different environment dynamics. To mitigate the problem of inefficient data use, there are some attempts that leverage Importance Sampling (IS) [13, 5, 14]. Given the dynamics of the target environment, samples from the source environments are assigned with larger importance weights if they are more likely to happen in the target environment and vice versa. Compared to training context encoders, IS-based methods manage to proactively exploit the data from other dynamics. However, such methods require prior knowledge about the dynamics of the target environment. Also, it is notoriously hard to balance the bias and variance when calculating the IS weights. This paper proposes a new RL paradigm that can explicitly leverage data with dynamics shift. It is also free of the aforementioned drawbacks of IS-based methods. We find that the stationary state distribution induced by optimal policies (later termed optimal state distribution) is similar across a set of environments with similar structures and different environment dynamics. For example, given heterogeneous preferences of users, a video recommendation system may choose different videos to recommend, but the optimal states are the same: users keep pressing the \u201clike\u201d or \u201csave\u201d button and continue watching for a long time. More concretely, the optimal state distribution in one environment dynamics can be informative for training policies in all other different dynamics. We therefore propose a constrained policy optimization (CPO) [15] formulation that requires the policy not only to optimize the cumulative return, but also to generate a stationary state distribution close to the optimal state distribution. By relating optimality to high-reward states [16], we are able to approximate the optimal state distribution from trajectory data regardless of the underlying dynamics, providing a unified and efficient approach to exploiting these data. Summarizing these ideas, we propose the SRPO (State Regularized Policy Optimization) algorithm. SRPO works as an add-on module in both online and offline context-based RL algorithms such as CaDM [9] and MAPLE [12] to increase their sample efficiency, leading to the CaDM+SRPO and MAPLE+SRPO algorithms. We provide a lower-bound performance guarantee on policies in one dynamics regularized by the optimal state distribution in other dynamics. This theoretically demonstrates the effectiveness of the SRPO algorithm in using data with dynamics shift. Empirical results in both online and offline settings show that SRPO can significantly improve both the data efficiency and the overall performance of several state-of-the-art context-based RL algorithms. We also perform ablation studies to demonstrate the effectiveness of each component in the SRPO algorithm. 2 Backgroud 2.1 Preliminaries A Markov Decision Process (MDP) can be defined by a tuple (S, A, T, r, \u03b3, \u03c10), where S is the state space, A is the bounded action space with actions a \u2208(\u22121, 1), T(s\u2032|s, a) \u2208[0, 1] and r(s, a, s\u2032) \u2208 [\u2212Rmax, Rmax] are the transition and reward functions. \u03b3 \u2208(0, 1) is the discount factor and \u03c10(s) is the initial state distribution. In MDPs with deterministic transitions, we denote T(s, a) as the transition function with a slight abuse of notation, and (T, \u03b5) as {T \u2032 | |T(s, a)\u2212T \u2032(s, a)| < \u03b5, \u2200s \u2208S, a \u2208A} which is the \u03b5\u2212neighbourhood of T. RL aims at maximizing the accumulated return of policy \u03c0: 2 \f\u03b7T (\u03c0)= E\u03c0,T \u0014 \u221e P t=0 \u03b3tr(st, at) \u0015 , where the expectation is computed with s0 \u223c\u03c10, at \u223c\u03c0(\u00b7|st), and st+1 \u223cT(\u00b7|st, at). The optimal policy \u03c0\u2217is defined as \u03c0\u2217 T = arg max \u03c0 \u03b7T (\u03c0). In an MDP with a policy \u03c0, the Q-value Q\u03c0 T (s, a) denotes the expected return after taking action a at state s: Q\u03c0 T (s, a)= E\u03c0,T \u0014 \u221e P t=0 \u03b3tr(st, at)|s0 = s, a0 = a \u0015 . The value function is defined as V \u03c0 T (s) = Ea\u223c\u03c0(\u00b7|s)Q\u03c0 T (s, a) with V \u2217 T (s) being the shorthand for V \u03c0\u2217 T T (s). It satisfies the optimal Bellman Equation V \u2217 T (s) = max a r(s, a) + \u03b3Es\u2032\u223cT (\u00b7|s,a)V \u2217 T (s\u2032). We can also define the stationary state distribution (also known as state occupation function) as d\u03c0 T (s) := (1 \u2212\u03b3) P\u221e t=0 \u03b3tPT (st = s | \u03c0) with d\u2217 T (s) being the shorthand for d\u03c0\u2217 T T (s). The Hidden Parameter Markov Decision Process (HiP-MDP) captures a class of MDPs with different transition functions and the same reward function by introducing a set of hidden parameters. Specifically, an HiP-MDP is defined by a tuple (S, A, \u0398, T, r, \u03b3, \u03c10), where \u0398 is the space of hidden parameters. The transition function T\u03b8(s\u2032|s, a, \u03b8) is parameterized not only by states and actions, but also by a hidden parameter \u03b8 sampled from \u0398. The action gap of an HiP-MDP is defined as \u2206= min \u03b8\u2208\u0398 min s\u2208S min a\u0338=\u03c0\u2217(s) V \u2217 T\u03b8(s) \u2212Q\u2217 T\u03b8(s, a), which reflects the minimum gap between an optimal action and all other sub-optimal actions. 2.2 Related Work MDPs with Different Dynamics The setting of HiP-MDP [17] was proposed to model a set of variations in the environment dynamics. The problem is intensively investigated in recent years [18] and these researches fall into three categories, i.e., encoder-based, Important Sampling (IS)-based and meta-RL based algorithms. Encoder-based methods extract the hidden parameters from trajectories with variational inference [19] or auxiliary loss [9]. These hidden parameters are used as inputs to the transition function [9] or policy network [20, 12]. Unfortunately, these methods train dynamicsspecific policies from the trajectory data of each hidden parameter independently, which leads to poor sample efficiency. Instead, our method uses the data from all dynamics to learn an optimal state distribution that facilitates the policy learning. IS-based methods compute the importance ratio between transition probabilities under different dynamics and modify the replay buffer [13, 14, 5] according to the transition probabilities in the test environments, which is often not available in real-world scenarios. Finally, meta-RL algorithms [21, 22] can adapt to environments with new dynamics through fine-tuning on a small amount of data from the test environment. In contrast, our method can be directly applied to new environment dynamics by making a zero-shot transfer. Behavior Regularized Methods The idea of constrained policy optimization (CPO) [15] is widely used in RL. Most researches focus on behavior regularized methods, i.e., adding policy constraints based on another policy distribution, as shown in the following optimization problem: max \u03c0 Es,a\u223cD \u0002 Ea\u2032\u223c\u03c0(\u00b7|s)Q(s, a\u2032) \u0003 s.t. Es\u223cD h \u02c6 D(\u03c0(\u00b7|s)\u2225\u02c6 \u03c0(\u00b7|s)) i < \u03b5, (1) where D is the replay buffer, \u02c6 \u03c0 is the regularizing policy, and \u02c6 D is a certain distance measure. Maximum-Entropy RL [23, 8] can be considered as CPO with a uniform policy distribution. The sparse action tasks [24] can be solved by CPO with a sparse policy distribution. Besides, many offline RL algorithms [25, 26, 27] are based on the idea of constraining the current policy distribution to be close to the dataset\u2019s policy distribution. However, data sampled from environments with different dynamics can have distinct optimal policies, as illustrated in Sec. 3.1. In such cases, \u02c6 \u03c0 in Eq. (1) may include policies that do not match the current environment, and can therefore be misleading. So behavior regularization in Eq. (1) would fail on data with dynamics shift. Differently, our proposed method is based on state regularization, which is more suitable when learning from data with dynamics shift. Leveraging stationary state distributions The stationary state distribution d\u03c0 T (s) of policy \u03c0 and dynamics T is an important feature that can measure the differences in policies and transition functions. It has already been exploited in many researches. In Off-Policy RL, Islam et. al [28] estimates the stationary state distributions of both the current policy and the mixed buffer policy. It 3 \fthen computes the off-policy policy gradient with the constraint that the two distributions should be close. Some Off-Policy Policy Evaluation (OPE) algorithms [29, 30] use the steady-state property of stationary Markov processes to estimate the stationary state distributions. In Imitation Learning (IL), state-only IL algorithms [31, 32] requires the stationary state distribution of the current policy to be close to that of the expert policy. In Inverse RL (IRL), [33] learns a stationary reward function by computing the gradient of the distance between agent and expert state distribution w.r.t. reward parameters. In Offline RL, [34] requires the stationary state distribution of the learning policy and the behavior policy to be close and perform conservative updates. The use of such distributions in our paper is similar to some researches on sim-to-real [35, 36]. They propose to match the next state distribution in the imperfect simulator and the real environment with inverse dynamics model. They implicitly relies on the idea that the same state distribution should generate similar returns in environments with different dynamics. We formulate the idea in this paper with theorems and quantitatively analyse such similarity in various conditions. 3 State Regularized Policy Optimization In this section, we first give motivating examples on why the optimal state distribution in one environment dynamics can be informative in all other different dynamics. A constrained policy optimization formulation is then proposed in Sec. 3.2 based on the optimal state distribution. Solving this optimization problem gives rise to our State Regularized Policy Optimization (SRPO) algorithm that can leverage data with dynamics shift to improve the policy performance. 3.1 Motivating Example 0.0 0.8 1.6 2.4 3.1 Angle -4.0 -2.0 0.0 2.0 4.0 Speed State Density with Gravity 5 0.0 0.8 1.6 2.4 3.1 Angle -4.0 -2.0 0.0 2.0 4.0 State Density with Gravity 10 25 20 15 10 5 0 -2.0 -1.0 0.0 1.0 2.0 Torque Action Density with Gravity 5 -2.0 -1.0 0.0 1.0 2.0 Torque Action Density with Gravity 10 5 0 Figure 2: Visualization of state and action densities in data sampled from the Inverted Pendulum environment with gravity 5 and 10. Under both gravities, the state distribution has high density with low pendulum speed and small pendulum angle. Meanwhile, the action distribution has different peaks in density under different gravities. The key intuition behind SRPO is that the optimal state distribution is similar across environments. Consider an example of the Inverted Pendulum environment in Fig. 2. We train two policies in the environments with gravities of 5 and 10 until convergence. Then the kernel density estimation [37] technique is employed to estimate the state and action density of the data collected by the two policies in different areas. It can be observed from the figure that collected data have the same high state density region with low pendulum speed and small pendulum angle, while the action distribution has different density peaks. It demonstrates that the state distribution of data generated by the optimal policy can be similar regardless of the environment dynamics, and therefore can serve as a reference distribution to regularize the training policy in environments with new dynamics. More demonstrating examples can be found at Appendix B.3. 3.2 State Regularized Policy Optimization Based on the intuition of informative optimal state distribution, we develop a novel technique that regulates RL algorithms to generate a stationary state distribution that is close to the optimal one. Specifically, we propose the following constrained policy optimization formulation: max \u03c0 Est,at\u223c\u03c4\u03c0 \" \u221e X t=0 \u03b3tr (st, at) # s.t. DKL (d\u03c0(\u00b7)\u2225\u03b6(\u00b7)) < \u03b5, (2) where \u03b6(s) is the optimal state distribution in other environment dynamics. By introducing the stationary state distribution, the optimization problem defined in Eq. (2) extends the regularization of in-distribution data to data with distribution shift. A similar form of Eq. (2) (See Eq. 1 in Sec. 2.2) is 4 \femployed in Offline RL algorithms to ensure conservative policy updates. But it restricts the training data to be sampled from the same environment. We solve Eq. (2) by casting it to the following unconstrained optimization problem via Lagrange multipliers: L = \u2212Est,at\u223c\u03c4 \" \u221e X t=0 \u03b3t \u0012 r(st, at) + \u03bb log \u03b6(st) d\u03c0(st) \u0013# \u2212 \u03bb\u03b5 1 \u2212\u03b3 , (3) where \u03bb > 0 is the Lagrangian Multiplier. The detailed derivations of the Lagrangian can be found in Appendix A.1. It is noteworthy that in addition to the multiplier term, the only difference of Eq. (3) and the reward-maximization objective of RL is that the logarithm of probability density ratio \u03bb log \u03b6(st) d\u03c0(st) is added to the reward term r(st, at). Therefore, one can easily apply our scheme to a wide range of RL algorithms by augmenting the reward function with the density ratio. 3.3 Data-based Surrogate of the Density Ratio The main challenge in solving Eq. (3) is to compute the density ratio \u03b6(s) d\u03c0(s) because obtaining the optimal state distribution during online training or given suboptimal offline dataset is infeasible. Also, d\u03c0(s) is intractable if the state space is continuous. Motivated by recent advances in adversarial training [38, 39], we propose a sample-based surrogate for the density ratio \u03b6(s) d\u03c0(s). Proposition 3.1. In a GAN, when the real data distribution is \u03b6(s) and the generated data distribution is d\u03c0(s), the output of the discriminator D(s) follows D(s) 1 \u2212D(s) = \u03b6(s) d\u03c0(s). (4) s1 a1 O1 s2 a2 O2 s3 a3 O3 s4 O4 Figure 3: HMM in MDP with optimality variables Ot. We discuss the relation of this sample-based surrogate with f-divergences and Off-Policy RL in Appendix A.3. To train the discriminator D(s), we need to generate samples that is close to the optimal state distribution \u03b6(s) and away from d\u03c0(s), which is sort of the average state distribution. Motivated by [16], we model state optimality by a variable Ot. As shown in Fig. 3, we regard the state st in MDP as a hidden state in a Hidden Markov Model (HMM), and introduce the binary observation state Ot. Ot = 1 denotes that st is the optimal state at timestep t. The observation model is given by p(Ot|st) = max at exp[\u03b3t(r(st, at) \u2212Rmax)]. (5) We can therefore compute the state density ratio \u03b6(s) d\u03c0(s) as \u03b6(s) d\u03c0(s) = d\u03c0(s|O0:\u221e) d\u03c0(s) = p(O0:\u221e|s, \u03c0)d\u03c0(s) p(O0:\u221e|\u03c0)d\u03c0(s) = Et[p(O0:t\u22121|st, \u03c0)p(Ot:\u221e|st, \u03c0)] p(O0:\u221e|\u03c0) , (6) where the second equation follows the Bayes\u2019 law. The last term is related to the forward probability \u03b1t(st) = p(O0:t\u22121|st, \u03c0) and backward probability \u03b2t(st) = p(Ot:\u221e|st, \u03c0) in the HMM. We discuss in Appendix A.2 that \u03b2t(st) is positively related to a soft version of MDP\u2019s state value V\u03c0(st). Also, \u03b1t(st) makes a little influence on the overall density ratio. Therefore, the input s will be more likely to be sampled from distribution \u03b6(s) if it has a higher state value V (s) than average. With this idea, we are able to build training samples for the discriminator D(s). 3.4 Practical Algorithm Summarizing the previous derivations, we obtain a practical reward regularization algorithm, termed as SRPO (State Regularized Policy Optimization) to leverage data with dynamics shift. We select the 5 \fAlgorithm 1 The workflow of SRPO on top of MAPLE [12]. 1: Input: \u03d5\u03c6 as a context encoder parameterized by \u03c6; Adaptable policy network \u03c0\u03b8 parameterized by \u03b8; Adaptable value network V\u03c8 parameterized by \u03c8; Offline dataset Doff ; Rollout horizon H; State partition ratio \u03c1; State discriminator D\u03b4 parameterized by \u03b4; Regularization coefficient \u03bb. 2: for 1, 2, 3, . . . do 3: for t = 1, 2, . . . , H do 4: Sample zt from \u03d5\u03c6 (z | st, at\u22121, zt\u22121) and then sample at from \u03c0\u03b8 (a | st, zt). 5: Rollout and get transition data (st+1, rt, dt+1, st, at, zt). Then add it to Drollout . 6: end for 7: Update the context encoder \u03d5\u03c6 according to MAPLE. 8: Sample a batch Dbatch from Doff and Drollout and rank them by their state-values estimated by V\u03c8; Add \u03c1|Dbatch| states with higher state-values to Dreal and the others to Dfake. 9: Train the discriminator D\u03b4 with nll loss. 10: For one-step transition (st+1, rt, dt+1, st, at, zt) in Dbatch, update rt with rt + \u03bb D\u03b4(st) 1\u2212D\u03b4(st). 11: Use the updated Dbatch and SAC to update the policy and value network parameters \u03b8 and \u03c8. 12: end for MAPLE [12] algorithm, which is one of the SOTA algorithms in context-based Offline RL, as the base algorithm. The detailed procedure of MAPLE+SRPO is shown in Alg. 1. After preparing the dataset in a model-based Offline RL style [40, 12], we sample a batch of data from the dataset, obtain a portion of \u03c1 states with higher rewards and add them to the dataset Dreal. Dfake is similarly generated by states with lower rewards (line 10). We set \u03c1 = 0.5 in offline experiments with medium-expert level of data. \u03c1 = 0.2 is set in all other experiments. Then a classifier discriminating data from the two datasets is trained (line 11). It estimates the logarithm of the state density ratio \u03bb log \u03b6(s) d\u03c0(s), which is added to the reward rt (line 12). \u03bb is regarded as a hyperparameter with values 0.1 or 0.3. The effect of \u03bb is investigated in Sec. 5.3. The procedure of the online algorithm CaDM [9]+SRPO is similar to MAPLE+SRPO, where the datasets Dreal and Dfake are built with data from the replay buffer, rather than the offline dataset. 4 Theoretical Analysis In this section, we analyze some properties of MDPs with different dynamics and provide theoretical justifications for the SRPO algorithm in Sec. 3. The notations are introduced in Sec. 2.1 and proofs can be found in Appendix A.4. We first show in Thm. 4.2 that the performance of a policy can be lower-bounded when its stationary state distribution is close to a certain optimal state distribution. In accordance with the intuition in Sec. 3.1, it is also demonstrated in Thm. 4.3 that optimal policies can induce the same stationary state distribution in different dynamics under mild assumptions. We start the analysis with the definition of homomorphous MDPs. Definition 4.1 (homomorphous MDPs). In an HiP-MDP (S, A, \u0398, T, r, \u03b3, \u03c10), consider hidden parameters \u03b81, \u03b82 \u2208\u0398. Let Ti(s\u2032|s, a) = T(s\u2032|s, a, \u03b8i), \u2200(s, a, s\u2032) \u2208S \u00d7 A \u00d7 S, i = 1, 2. If P a\u2208A T1(s\u2032|s, a) > 0 \u21d4 P a\u2208A T2(s\u2032|s, a) > 0 for all s, s\u2032 \u2208S, MDPs (S, A, T1, r, \u03b3, \u03c10) and (S, A, T2, r, \u03b3, \u03c10) are referred to as homomorphous MDPs. In this definition, P a\u2208A T(s\u2032|s, a) > 0 means state s\u2032 can be reached from s, so the equivalence of non-zero transition probabilities refers to the same reachability from s to s\u2032. Such condition holds in a wide range of MDPs differing only in environment parameters. For example, pendulums with different lengths can all reach the upright state from an off-center state, with longer pendulums exerting a larger force. Apart from the homomorphous property, we also require the reward and dynamics functions of MDPs to have Lipschitz properties. We assume reward function r(s, a, s\u2032) w.r.t. the action a is \u03bb1-Lipschitz and the dynamics function T(s, a) w.r.t. the action a is \u03bb2-inverse Lipschitz. Discussions on these Lipschitz properties can be found in Appendix A.5. With these preliminaries, we first analyze the discrepancy of accumulated returns of two policies with similar stationary state distributions. The analysis is related to our SRPO algorithm in that the state regularized policy optimization formulation in Eq. (2) also constrains the learning policy to have 6 \fa similar stationary state distribution with the optimal policy. Specifically, we derive a theorem as follows. Theorem 4.2. Consider two homomorphous MDPs with dynamics T and T \u2032. If T \u2032 \u2208(T, \u03b5m), for all learning policy \u02c6 \u03c0 such that DKL(d\u02c6 \u03c0 T (\u00b7)\u2225d\u2217 T \u2032(\u00b7)) \u2a7d\u03b5s, we have \u03b7T (\u02c6 \u03c0) \u2a7e\u03b7T (\u03c0\u2217 T ) \u2212\u03bb1\u03bb2\u03b5m + 2\u03bb1 + \u221a 2Rmax\u221a\u03b5s 1 \u2212\u03b3 . (7) The theorem implies that if a policy \u02c6 \u03c0 has a similar stationary state distribution with the optimal policy in one MDP M, \u02c6 \u03c0 will have a lower-bound performance guarantee in all MDPs that are homomorphous with the MDP M. Therefore, the learning policy can benefit from the state regularized policy optimization in Sec. 3.2. More specifically, Eq. (7) shows that the gap in accumulated return of \u02c6 \u03c0 and \u03c0\u2217 T is related to the dynamics shift \u03b5m, the KL-Divergence of two stationary state distributions \u03b5s, and the effective planning horizon 1 1\u2212\u03b3 . With respect to the dynamics shift \u03b5m, it is related to a \u201cuniform\u201d constraint on the dynamics T \u2032. We further show in Appendix A.4 that constraining the dynamics shift on a certain state-action pair is enough to derive Eq. (7). Unlike the dynamics shift \u03b5m that is determined by a pre-defined RL task, the discrepancy between stationary state distributions \u03b5s is determined by the learning policy \u02c6 \u03c0 and can be optimized during training to obtain a better performance lower-bound. We also discuss in Appendix A.5 how tight Eq. (7) is in terms of the effective planning horizon 1 1\u2212\u03b3 , compared with some similar performance bounds. With an additional assumption on the action gap \u2206(defined in Sec. 2.1), we further demonstrate that the optimal policy of two homomorphous MDPs can have the same stationary state distribution, which verifies the intuition in Sec. 3.1. Theorem 4.3. Consider two homomorphous MDPs with dynamics T and T \u2032. If T \u2032 \u2208(T, \u03b5m) and the action gap \u2206follows \u2206> (2\u2212\u03b3)\u03bb1\u03bb2\u03b5m 1\u2212\u03b3 , for all s \u2208S we have d\u2217 T (s) = d\u2217 T \u2032(s). The assumption is mild and holds in many scenarios. For example, in autonomous driving it can be very dangerous to deviate from the optimal policy. Such suboptimal actions have low rewards, leading to a large action gap \u2206. In recommendation tasks we are hardly concerned with what items we recommend (the action), as long as the recommendation outcome (the state), i.e., the users\u2019 experiences are good enough, leading to a small \u03bb1. The condition of large enough action gap holds in these situations. 5 Experiments In this section, we conduct experiments to investigate the following questions: (1) Can SRPO leverage data with distribution shift and outperform current SOTA algorithms in the setting of HiP-MDP, in both online and offline RL? (2) How does each component of SRPO (e.g., use state regularization rather than behavior regularization) contribute to SRPO\u2019s performance? To answer question (1), we use the MuJoCo simulator [41] and generate environments with different transition functions. We train the CaDM+SRPO and the MAPLE+SRPO algorithm proposed in Sec. 3.4 and make comparative analysis with baseline algorithms. To answer question (2), we do ablation studies to examine the role of different modules in SRPO. We also examine how the discriminator D\u03b4 works in complex environments and the effect of regularizing with state distributions in different performance levels. 5.1 Experiment Setup We alter the simulator gravity to generate different dynamics in online experiments. Possible values of gravity are {1.0}, {0.7,1.0,1.3}, and {0.4,0.7,1.0,1.3,1.6} in experiments with 1, 3, and 5 kinds of different dynamics, respectively. When the simulator resets, the gravity is uniformly sampled from the set of all possible values. The number of training steps is in proportion to the number of environment parameters. Therefore, the agent has access to the same amount of training data on a certain value of simulator gravity. We also consider the shift of medium density and body mass in offline experiments to show SRPO\u2019s robustness to different forms of dynamics shift. To perform comparative analysis, we choose CaDM [9] and PPO [7] as baseline algorithms in online experiments. In offline experiments, DARA [5] also exploits large amount of data with dynamics 7 \f0.0 0.3 0.6 0.9 1.2 1.5 1.4 1.2 1.0 0.8 0.6 0.4 \u00d7103 Pendulum (3 Different Dynamics) 0 1 2 3 4 5 6 0.0 0.5 1.0 1.5 2.0 2.5 \u00d7102 Ant (3 Different Dynamics) 0 1 2 3 4 5 6 0.0 0.5 1.0 1.5 2.0 2.5 3.0 \u00d7103 HalfCheetah (3 Different Dynamics) 0 1 2 3 4 5 6 0.0 0.2 0.4 0.6 0.8 1.0 1.2 \u00d7105 Humanoid (3 Different Dynamics) 0.0 0.5 1.0 1.5 2.0 2.5 Timesteps(M) 1.4 1.2 1.0 0.8 0.6 0.4 \u00d7103 \u00d7103 Pendulum (5 Different Dynamics) 0 2 4 6 8 10 Timesteps(M) 0 1 2 3 4 5 \u00d7102 \u00d7102 Ant (5 Different Dynamics) 0 2 4 6 8 10 Timesteps(M) 0 1 2 3 4 \u00d7103 \u00d7103 HalfCheetah (5 Different Dynamics) 0 2 4 6 8 10 Timesteps(M) 0.0 0.2 0.4 0.6 0.8 1.0 1.2 \u00d7104 \u00d7105 Humanoid (5 Different Dynamics) PPO CaDM CaDM+SRPO Figure 4: Results of online experiments on MuJoCo tasks. The comparison is made between CaDM+SRPO and baseline algorithms PPO, CaDM. Our CaDM+SRPO algorithm has the best overall performance in experiments with 3 and 5 different environment dynamics. The curves show the average return on 4 random seeds and the shadow areas reflect the standard deviation. Table 1: Results of offline experiments on MuJoCo tasks. Numbers are the normalized scores according to the D4RL paper [42]. ME, M, MR and R correspond to the medium-expert, expert, medium-replay and random dataset, respectively. The evaluation is done on policies at the last iteration of training, averaged over four random seeds. The number after \u00b1 is the standard deviation. Our proposed MAPLE+SRPO algorithm has the best performance in 8 of 12 tasks and the highest overall performance. CQL (Single Env) GAIL CQL MOPO MAPLE MAPLE +DARA MAPLE +SRPO(Ours) Walker2d-ME 1.11 0.21\u00b10.03 1.03\u00b10.10 0.25\u00b10.18 0.55\u00b10.21 0.80\u00b10.02 0.66\u00b10.08 Walker2d-M 0.79 0.15\u00b10.06 0.78\u00b10.01 0.23\u00b10.34 0.82\u00b10.01 0.83\u00b10.03 0.84\u00b10.03 Walker2d-MR 0.27 0.00\u00b10.00 0.07\u00b10.00 0.00\u00b10.00 0.16\u00b10.02 0.17\u00b10.01 0.17\u00b10.02 Walker2d-R 0.07 0.00\u00b10.00 0.03\u00b10.01 0.00\u00b10.00 0.22\u00b10.00 0.22\u00b10.00 0.22\u00b10.00 Hopper-ME 0.98 0.04\u00b10.01 0.32\u00b10.14 0.01\u00b10.00 0.96\u00b10.14 0.96\u00b10.06 0.98\u00b10.02 Hopper-M 0.58 0.00\u00b10.00 0.57\u00b10.16 0.01\u00b10.00 0.78\u00b10.28 0.40\u00b10.05 1.03\u00b10.09 Hopper-MR 0.46 0.00\u00b10.00 0.14\u00b10.02 0.01\u00b10.01 0.91\u00b10.11 1.02\u00b10.01 1.02\u00b10.01 Hopper-R 0.11 0.00\u00b10.00 0.11\u00b10.00 0.01\u00b10.00 0.13\u00b10.00 0.13\u00b10.01 0.32\u00b10.02 HalfCheetah-ME 0.62 0.36\u00b10.06 0.03\u00b10.04 -0.03\u00b10.00 0.50\u00b10.06 0.50\u00b10.00 0.63\u00b10.01 HalfCheetah-M 0.44 0.25\u00b10.02 0.43\u00b10.03 0.38\u00b10.28 0.62\u00b10.01 0.67\u00b10.03 0.63\u00b10.01 HalfCheetah-MR 0.46 0.18\u00b10.11 0.46\u00b10.00 -0.03\u00b10.00 0.52\u00b10.00 0.53\u00b10.01 0.55\u00b10.00 HalfCheetah-R 0.35 0.14\u00b10.02 0.01\u00b10.02 -0.03\u00b10.00 0.22\u00b10.03 0.21\u00b10.00 0.24\u00b10.01 Average 0.52 0.11 0.33 0.068 0.53 0.54 0.61 shift. Its algorithm relies on Importance Sampling and will be used as a baseline method. Apart from that, we choose MOPO [40], MAPLE [12] and CQL [26] as baseline methods. More information on the setup of experiments is shown in Appendix B.1. 5.2 Results Online Experiments The results of online experiments are shown in Fig. 4. With the context encoder and conditional policy, CaDM is able to outperform PPO in all environments. However, it fails to take advantage of the increase in the amount of data with dynamics shift. Its performance with 5 different dynamics is lower than that with 3 dynamics. In contrast, our proposed SRPO algorithm leads to better performance on top of CaDM in accordance with more training data. It significantly outperforms the original CaDM algorithm in environments with 5 different dynamics. The performance comparison in the Pendulum environment is also in accordance with the motivating example in Sec. 3.1. More results of online experiments are shown in Appendix B.2. 8 \fTable 2: Results of ablation studies in offline experiments. MAPLE +SRPO Behavior Regularizing Random Partition Fixed \u03bb = 0.3 Walker2d 0.47 0.45 0.39 0.40 Hopper 0.83 0.68 0.56 0.79 HalfCheetah 0.51 0.50 0.45 0.40 Average 0.61 0.54 0.47 0.53 Table 3: Performance comparison of differently regularized policies. Original Hopper Env 10x Density Random 121.3 44.15 Medium 2178 913.3 Expert 3819 3748 Offline Experiments The results of offline experiments are shown in Tab. 1. The column of \u201cCQL Single\u201d refers to the evaluation score in the CQL [26] paper, where the policy is with data from a single static environment. Without the mechanism of context-based encoders, GAIL [43], CQL and MOPO [40] cannot handle data with distribution shift and show a performance drop. MAPLE [12] and MAPLE+DARA [5] only achieve marginal performance improvement with respect to CQL single. On the other hand, MAPLE+SRPO shows significant performance improvement over CQL single, which means that SRPO can efficiently leverage the additional data with dynamics shift to facilitate policy training. The MAPLE+SRPO algorithm also has a 15% higher evaluation score than MAPLE, achieving the best performance in 8 out of 12 tasks. Apart from MAPLE, the meta-RL algorithm PEARL [44] also has an context encoder for fast adaptation. We compare PEARL with PEARL+SRPO and leave the results in Appendix. B.3. 5.3 Analysis Ablations We conduct ablation studies in offline environments to analyze the role of each algorithm component in SRPO. The results are shown in Tab. 2. We first investigate the outcome of regularizing with state-action distribution rather than state distribution in Eq. (2). The resulting policy has a lower evaluation score on average than policies trained with the original SRPO algorithm in all environments. This is because environments with different dynamics do not have a similar optimal policy. The action distribution in the mixed dataset can be misleading when training new policies. According to Sec. 3.3, SRPO trains a classifier to discriminate states with higher values from lower values. We also train another classifier discriminating a random binary partition of states. Ablation results show a huge performance drop, which verifies the effectiveness of the classification-based surrogate mechanism. We also evaluate MAPLE+SRPO with a fixed value of the hyperparameter \u03bb. \u03bb = 0.1 is more suitable for Walker2d and HalfCheetah environments, while in the Hopper environment \u03bb = 0.3 is better. This is in accordance with previous analysis that Hopper agents can benefit more from regularizing with the stationary state distribution. Walker2d Hopper HalfCheetah Envrironment 0.4 0.6 0.8 1.0 1.2 Normalized Values State Values With Different D Output High Low Random Medium Policy T ype 0.2 0.4 0.6 0.8 1.0 Normalized Value Gaps Value Gaps of Different  Figure 5: Comparison of values on states with high and low output of the discriminator D. Effectiveness of Discriminators We first train a discriminator D\u03b4 according to Alg. 1. Then a set of states is sampled from the D4RL [42] dataset and classified into two sets according to the output of D\u03b4. The average values of the two sets of states are compared in Fig. 5. As shown in the figure, states with higher D\u03b4 outputs also have higher values in all three environments. It means that the trained discriminator D\u03b4 can successfully identify states with high values from those with low values. Therefore, its output can be a good surrogate for the density ratio \u03b6(s) d\u03c0(s) in Sec. 3. Effectiveness of the Regularization We also study the effect of policy regularization with different performance levels of stationary state distributions. Random, medium and expert policies in the original Hopper environment are used to estimate the stationary state distributions, which regularize the learning policies in a new environment with different dynamics. The results are shown in Tab. 3, where the expert policy is the most effective in regularizing. This verifies the practice in Sec. 3.2 and the theoretical analysis. 9 \f6"
+                },
+                {
+                    "url": "http://arxiv.org/abs/2303.01728v2",
+                    "title": "Guarded Policy Optimization with Imperfect Online Demonstrations",
+                    "abstract": "The Teacher-Student Framework (TSF) is a reinforcement learning setting where\na teacher agent guards the training of a student agent by intervening and\nproviding online demonstrations. Assuming optimal, the teacher policy has the\nperfect timing and capability to intervene in the learning process of the\nstudent agent, providing safety guarantee and exploration guidance.\nNevertheless, in many real-world settings it is expensive or even impossible to\nobtain a well-performing teacher policy. In this work, we relax the assumption\nof a well-performing teacher and develop a new method that can incorporate\narbitrary teacher policies with modest or inferior performance. We instantiate\nan Off-Policy Reinforcement Learning algorithm, termed Teacher-Student Shared\nControl (TS2C), which incorporates teacher intervention based on\ntrajectory-based value estimation. Theoretical analysis validates that the\nproposed TS2C algorithm attains efficient exploration and substantial safety\nguarantee without being affected by the teacher's own performance. Experiments\non various continuous control tasks show that our method can exploit teacher\npolicies at different performance levels while maintaining a low training cost.\nMoreover, the student policy surpasses the imperfect teacher policy in terms of\nhigher accumulated reward in held-out testing environments. Code is available\nat https://metadriverse.github.io/TS2C.",
+                    "authors": "Zhenghai Xue, Zhenghao Peng, Quanyi Li, Zhihan Liu, Bolei Zhou",
+                    "published": "2023-03-03",
+                    "updated": "2023-04-24",
+                    "primary_cat": "cs.LG",
+                    "cats": [
+                        "cs.LG",
+                        "cs.AI",
+                        "cs.RO"
+                    ],
+                    "main_content": "INTRODUCTION In Reinforcement Learning (RL), the Teacher-Student Framework (TSF) (Zimmer et al., 2014; Kelly et al., 2019) incorporates well-performing neural controllers or human experts as teacher policies in the learning process of autonomous agents. At each step, the teacher guards the free exploration of the student by intervening when a speci\ufb01c intervention criterion holds. Online data collected from both the teacher policy and the student policy will be saved into the replay buffer and exploited with Imitation Learning or Off-Policy RL algorithms. Such a guarded policy optimization pipeline can either provide safety guarantee (Peng et al., 2021) or facilitate ef\ufb01cient exploration (Torrey & Taylor, 2013). The majority of RL methods in TSF assume the availability of a well-performing teacher policy (Spencer et al., 2020; Torrey & Taylor, 2013) so that the student can properly learn from the teacher\u2019s demonstration about how to act in the environment. The teacher intervention is triggered when the student acts differently from the teacher (Peng et al., 2021) or when the teacher \ufb01nds the current state worth exploring (Chisari et al., 2021). This is similar to imitation learning where the training outcome is signi\ufb01cantly affected by the quality of demonstrations (Kumar et al., 2020; Fujimoto et al., 2019). Thus with current TSF methods if the teacher is incapable of providing high-quality demonstrations, the student will be misguided and its \ufb01nal performance will be upperbounded by the performance of the teacher. However, it is time-consuming or even impossible to obtain a well-performing teacher in many real-world applications such as object manipulation with robot arms (Yu et al., 2020) and autonomous driving (Li et al., 2022a). As a result, current TSF methods will behave poorly with a less capable teacher. In the real world, the coach of Usain Bolt does not necessarily need to run faster than Usain Bolt. Is it possible to develop a new interactive learning scheme where a student can outperform the teacher while retaining safety guarantee from it? In this work we develop a new guarded policy optimization 1 arXiv:2303.01728v2  [cs.LG]  24 Apr 2023 \fPublished as a conference paper at ICLR 2023 method called Teacher-Student Shared Control (TS2C). It follows the setting of a teacher policy and a learning student policy, but relaxes the requirement of high-quality demonstrations from the teacher. A new intervention mechanism is designed: Rather than triggering intervention based on the similarity between the actions of teacher and student, the intervention is now determined by a trajectory-based value estimator. The student is allowed to conduct an action that deviates from the teacher\u2019s, as long as its expected return is promising. By relaxing the intervention criterion from step-wise action similarity to trajectory-based value estimation, the student has the freedom to act differently when the teacher fails to provide correct demonstration and thus has the potential to outperform the imperfect teacher. We conduct theoretical analysis and show that in previous TSF methods the quality of the online data-collecting policy is upper-bounded by the performance of the teacher policy. In contrast, TS2C is not limited by the imperfect teacher in upper-bound performance, while still retaining a lower-bound performance and safety guarantee. Experiments on various continuous control environments show that under the newly proposed method, the learning student policy can be optimized ef\ufb01ciently and safely under different levels of teachers while other TSF algorithms are largely bounded by the teacher\u2019s performance. Furthermore, the student policies trained under the proposed TS2C substantially outperform all baseline methods in terms of higher ef\ufb01ciency and lower test-time cost, supporting our theoretical analysis. 2 BACKGROUND 2.1 RELATED WORK The Teacher-Student Framework The idea of transferring knowledge from a teacher policy to a student policy has been explored in reinforcement learning (Zimmer et al., 2014). It improves the learning ef\ufb01ciency of the student policy by leveraging a pretrained teacher policy, usually by adding auxiliary loss to encourage the student policy to be close to the teacher policy (Traor\u00b4 e et al., 2019). Though our method follows teacher-student transfer framework, an optimal teacher is not a necessity. During training, agents are fully controlled by either the student (Traor\u00b4 e et al., 2019) or the teacher policy (Rusu et al., 2018), while our method follows intervention-based RL where a mixed policy controls the agent. Other attempts to relax the need of well-performing teacher models include student-student transfer (Lin et al., 2017; Lai et al., 2020), in which heterogeneous agents exchange knowledge through mutual regularisation (Zhao & Hospedales, 2021; Peng et al., 2020). Learning from Demonstrations Another way to exploit the teacher policy is to collect of\ufb02ine and static demonstration data from it. The learning agent will regard the demonstration as optimal transitions to imitate from. If the data is provided without reward signals, agent can learn by imitating the teacher\u2019s policy distribution (Ly & Akhlou\ufb01, 2020), matching the trajectory distribution (Ho & Ermon, 2016; Xu et al., 2019) or learning a parameterized reward function with inverse reinforcement learning (Abbeel & Ng, 2004; Fu et al., 2017). There are also algorithms that take the imperfect demonstrations into consideration (Zhang et al., 2021; Xu et al., 2022). With additional reward signals, agents can perform Bellman updates pessimistically, as most of\ufb02ine reinforcement learning algorithms do (Levine et al., 2020). In contrast to the of\ufb02ine learning from demonstrations, in this work we focus on the online deployment of teacher policies with teacher-student shared control and show its superiority in reducing the state distributional shift, improving ef\ufb01ciency and ensuring training-time safety. Intervention-based Reinforcement Learning Intervention-based RL enables both the expert and the learning agent to generate online samples in the environment. The switch between policies can be random (Ross et al., 2011), rule-based (Parnichkun et al., 2022) or determined by the expert, either through the manual intervention of human participators (Abel et al., 2017; Chisari et al., 2021; Li et al., 2022b) or by referring to the policy distribution of a parameterized expert (Peng et al., 2021). More delicate switching algorithms include RCMP (da Silva et al., 2020) which asks for expert advice when the learner\u2019s action has high estimated uncertainty. RCMP only works for agents with discrete action spaces, while we investigate continuous action space in this paper. Also, Ross & Bagnell (2014) and Sun et al. (2017) query the expert to obtain the optimal value function, which is used to guide the expert intervention. These switching mechanisms assume the expert policy to be optimal, while our proposed algorithm can make use of a suboptimal expert policy. To exploit samples collected with different policies, Ross et al. (2011) and Kelly et al. (2019) compute behavior cloning loss on samples where the expert policy is in control and discard those generated by the 2 \fPublished as a conference paper at ICLR 2023 learner. Other algorithms (Mandlekar et al., 2020; Chisari et al., 2021) assign positive labels on expert samples and compute policy gradient loss based on the pseudo reward. Some other research works focus on provable safety guarantee with shared control (Peng et al., 2021; Wagener et al., 2021), while we provide an additional lower-bound guarantee of the accumulated reward for our method. 2.2 NOTATIONS We consider an in\ufb01nite-horizon Markov decision process (MDP), de\ufb01ned by the tuple M = \u27e8S, A, P, R, \u03b3, d0\u27e9consisting of a \ufb01nite state space S, a \ufb01nite action space A, the state transition probability distribution P : S \u00d7 A \u00d7 S \u2192[0, 1], the reward function R : S \u00d7 A \u2192[Rmin, Rmax], the discount factor \u03b3 \u2208(0, 1) and the initial state distribution d0 : S \u2192[0, 1]. Unless otherwise stated, \u03c0 denotes a stochastic policy \u03c0 : S \u00d7A \u2192[0, 1]. The state-action value and state value functions of \u03c0 are de\ufb01ned as Q\u03c0(s, a) = Es0=s,a0=a,at\u223c\u03c0(\u00b7|st),st+1\u223cp(\u00b7|st,at) [P\u221e t=0 \u03b3tR (st, at)] and V \u03c0(s) = Ea\u223c\u03c0(\u00b7|s)Q\u03c0(s, a). The optimal policy is expected to maximize the accumulated return J(\u03c0) = Es\u223cd0V \u03c0(s). The Teacher-Student Framework (TSF) models the shared control system as the combination of a teacher policy \u03c0t which is pretrained and \ufb01xed and a student policy \u03c0s to be learned. The actual actions applied to the agent are deduced from a mixed policy of \u03c0t and \u03c0s, where \u03c0t starts generating actions when intervention happens. The details of the intervention mechanism are described in Sec. 3.2. The goal of TSF is to improve the training ef\ufb01ciency and safety of \u03c0s with the involvement of \u03c0t. The discrepancy between \u03c0t and \u03c0s on state s, termed as policy discrepancy, is the L1-norm of output difference: \u2225\u03c0t(\u00b7|s) \u2212\u03c0s(\u00b7|s)\u22251 = R A |\u03c0t(a|s) \u2212\u03c0s(a|s)| da. We de\ufb01ne the discounted state distribution under policy \u03c0 as d\u03c0(s) = (1 \u2212\u03b3) P\u221e t=0 \u03b3t Pr (st = s; \u03c0, d0), where Pr\u03c0 (st = s; \u03c0, d0) is the state visitation probability. The state distribution discrepancy is de\ufb01ned as the difference in L1-norm of the discounted state distributions deduced from two policies: \u2225d\u03c0t \u2212d\u03c0s\u22251 = R S |d\u03c0t(s) \u2212d\u03c0s(s)| ds. 3 GUARDED POLICY OPTIMIZATION WITH ONLINE DEMONSTRATIONS Shared Control Student Teacher Warmup Sampling Value Estimator Action Intervention Function Environment Action Action Update Replay Buffer Transition Figure 1: Overview of the proposed teacherstudent shared control method. Both student and teacher policies are in the training loop and the shared control occurs based on the intervention function. Fig. 1 shows an overview of our proposed method. In addition to the conventional singleagent RL setting, we include a teacher policy \u03c0t in the training loop. The term \u201cteacher\u201d only indicates that the role of this policy is to help the student training. No assumption on the optimality of the teacher is needed. The teacher policy is \ufb01rst used to do warmup rollouts and train a value estimator. During the training of the student policy, both \u03c0s and \u03c0t receive current state s from the environment. They propose actions as and at, and then a value-based intervention function T (s) determines which action should be taken and applied to the environment. The student policy is then updated with data collected through such intervention. We \ufb01rst give a theoretical analysis on the general setting of intervention-based RL in Sec. 3.1. We then discuss the properties of different forms of intervention function T in Sec. 3.2. Based on these analyses, we propose a new algorithm for teacher-student shared control in Sec. 3.3. All the proofs in this section are included in Appendix A.1. 3.1 ANALYSIS ON INTERVENTION-BASED RL In intervention-based RL, the teacher policy and the student policy act together and become a mixed behavior policy \u03c0b. The intervention function T (s) determines which policy is in charge. Let T (s) = 1 denotes the teacher policy \u03c0t takes control and T (s) = 0 means otherwise. Then \u03c0b can be represented as \u03c0b(\u00b7|s) = T (s)\u03c0t(\u00b7|s) + (1 \u2212T (s))\u03c0s(\u00b7|s). 3 \fPublished as a conference paper at ICLR 2023 One issue with the joint control is that the student policy \u03c0s is trained with samples collected by the behavior policy \u03c0b, whose action distribution is not always aligned with \u03c0s. A large state distribution discrepancy between two policies \u2225d\u03c0b \u2212d\u03c0s\u22251 can cause distributional shift and ruin the training. A similar problem exists in behavior cloning (BC), though in BC no intervention is involved and \u03c0s learns from samples all collected by the teacher policy \u03c0t. To analyze the state distribution discrepancy in BC, we \ufb01rst introduce a useful lemma (Achiam et al., 2017). Lemma 3.1. The state distribution discrepancy between the teacher policy \u03c0t and the student policy \u03c0s is bounded by their expected policy discrepancy: \u2225d\u03c0t \u2212d\u03c0s\u22251 \u2a7d \u03b3 1 \u2212\u03b3 Es\u223cd\u03c0t \u2225\u03c0t(\u00b7 | s) \u2212\u03c0s(\u00b7 | s)\u22251 . (1) We apply the lemma to the setting of intervention-based RL and derive a bound for \u2225d\u03c0b \u2212d\u03c0s\u22251. Theorem 3.2. For any behavior policy \u03c0b deduced by a teacher policy \u03c0t, a student policy \u03c0s and an intervention function T (s), the state distribution discrepancy between \u03c0b and \u03c0s is bounded by \u2225d\u03c0b \u2212d\u03c0s\u22251 \u2a7d \u03b2\u03b3 1 \u2212\u03b3 Es\u223cd\u03c0b \u2225\u03c0t(\u00b7 | s) \u2212\u03c0s(\u00b7 | s)\u22251 , (2) where \u03b2 = Es\u223cd\u03c0b [T (s)\u2225\u03c0t(\u00b7|s)\u2212\u03c0s(\u00b7|s)\u22251] Es\u223cd\u03c0b \u2225\u03c0t(\u00b7|s)\u2212\u03c0s(\u00b7|s)\u22251 \u2208[0, 1] is the expected intervention rate weighted by the policy discrepancy. Both Eq. 1 and Eq. 2 bound the state distribution discrepancy by the difference in per-state policy distributions, but the upper bound with intervention is squeezed by the intervention rate \u03b2. In practical algorithms, \u03b2 can be minimized to reduce the state distribution discrepancy and thus relieve the performance drop during test time. Based on Thm. 3.2, we further prove in Appendix A.1 that under the setting of intervention-based RL, the accumulated returns of behavior policy J(\u03c0b) and student policy J(\u03c0s) can be similarly related. The analysis in this section does not assume a certain form of the intervention function T (s). Our analysis provides the insight on the feasibility and ef\ufb01ciency of all previous algorithms in intervention-based RL (Kelly et al., 2019; Peng et al., 2021; Chisari et al., 2021). In the following section, we will examine different forms of intervention functions and investigate their properties and performance bounds, especially with imperfect online demonstrations. 3.2 LEARNING FROM IMPERFECT DEMONSTRATIONS A straightforward idea to design the intervention function is to intervene when the student acts differently from the teacher. We model such process with the action-based intervention function Taction(s): Taction(s) = (1 if Ea\u223c\u03c0t( \u00b7|s)[log \u03c0s(a | s)] < \u03b5, 0 otherwise, (3) wherein \u03b5 > 0 is a prede\ufb01ned parameter. A similar intervention function is used in EGPO (Peng et al., 2021), where the student\u2019s action is replaced by the teacher\u2019s if the student\u2019s action has low probability under the teacher\u2019s policy distribution. To measure the effectiveness of a certain form of intervention function, we examine the return of the behavior policy J(\u03c0b). With Taction(s) de\ufb01ned in Eq. 3 we can bound J(\u03c0b) with the following theorem. Theorem 3.3. With the action-based intervention function Taction(s), the return of the behavior policy J(\u03c0b) is lower and upper bounded by J(\u03c0t)+ \u221a 2(1 \u2212\u03b2)Rmax (1 \u2212\u03b3)2 \u221a H \u2212\u03b5 \u2a7eJ(\u03c0b) \u2a7eJ(\u03c0t) \u2212 \u221a 2(1 \u2212\u03b2)Rmax (1 \u2212\u03b3)2 \u221a H \u2212\u03b5, (4) where H = Es\u223cd\u03c0b H(\u03c0t(\u00b7|s)) is the average entropy of the teacher policy during shared control and \u03b2 is the weighted intervention rate in Thm. 3.2. The theorem shows that J(\u03c0b) can be lower bounded by the return of the teacher policy \u03c0t and an extra term relating to the entropy of the teacher policy. It implies that action-based intervention function Taction is indeed helpful in providing training data with high return. We discuss the tightness of Thm. 3.3 and give an intuitive interpretation of \u221a H \u2212\u03b5 in Appendix A.2. 4 \fPublished as a conference paper at ICLR 2023 Student trajectory Teacher trajectory Student action Teacher action Figure 2: In an autonomous driving scenario, the ego vehicle is the blue one on the left, following the gray vehicle on the right. The upper trajectory is proposed by the student to overtake and the lower trajectory is proposed by the teacher to keep following. A drawback of the action-based intervention function is the strong assumption on the optimal teacher, which is not always feasible. If we turn to employ a suboptimal teacher, the behavior policy would be burdened due to the upper bound in Eq. 4. We illustrate this phenomenon with the example in Fig. 2 where a slow vehicle in gray is driving in front of the ego-vehicle in blue. The student policy is aggressive and would like to overtake the gray vehicle to reach the destination faster, while the teacher intends to follow the vehicle conservatively. Therefore, \u03c0s and \u03c0b will propose different actions in the current state, leading to Taction = 1 according to Eq. 3. The mixed policy with shared control will always choose to follow the front vehicle and the agent can never accomplish a successful overtake. To empower the student to outperform a suboptimal teacher policy, we investigate a new form of intervention function that encapsulates the long-term value estimation into the decision of intervention, designed as follows: Tvalue(s) = (1 if V \u03c0t (s) \u2212Ea\u223c\u03c0s(\u00b7|s)Q\u03c0t (s, a) > \u03b5, 0 otherwise, (5) where \u03b5 > 0 is a prede\ufb01ned parameter. By using this intervention function, the teacher tolerates student\u2019s action if the teacher can not perform signi\ufb01cantly better than the student by \u03f5 in return. Tvalue no longer expects the student to imitate the teacher policy step-by-step. Instead, it makes decision on the basis of long-term return. Taking trajectories in Fig. 2 again as an example, if the overtake behavior has high return, the student will be preferable to Tvalue. Then the student control will not be intervened by the conservative teacher. So with the value-based intervention function, the agent\u2019s exploration ability will not be limited by a suboptimal teacher. Nevertheless, the lowerbound performance guarantee of the behavior policy \u03c0b still holds, shown as follows. Theorem 3.4. With the value-based intervention function Tvalue(s) de\ufb01ned in Eq. 5, the return of the behavior policy \u03c0b is lower bounded by J (\u03c0b) \u2a7eJ (\u03c0t) \u2212(1 \u2212\u03b2)\u03b5 1 \u2212\u03b3 . (6) In safety-critical scenarios, the step-wise training cost c(s, a), i.e., the penalty on the safety violation during training, can be regarded as a negative reward. We de\ufb01ne \u02c6 r(s, a) = r(s, a) \u2212\u03b7c(s, a) as the combined reward, where \u03b7 is the weighting hyperparameter. \u02c6 V , \u02c6 Q and \u02c6 Tvalue are similarly de\ufb01ned by substituting r with \u02c6 r in the original de\ufb01nition. Then we have the following corollary related to expected cumulative training cost, de\ufb01ned by C(\u03c0) = Es0\u223cd0,at\u223c\u03c0(\u00b7|st),st+1\u223cp(\u00b7|st,at) [P\u221e t=0 \u03b3tc (st, at)]. Corollary 3.5. With safety-critical value-based intervention function \u02c6 Tvalue(s), the expected cumulative training cost of the behavior policy \u03c0b is upper bounded by C(\u03c0b) \u2a7dC(\u03c0t) + (1 \u2212\u03b2)\u03f5 \u03b7(1 \u2212\u03b3) + 1 \u03b7 [J(\u03c0b) \u2212J(\u03c0t)] . (7) In Eq. 7 the upper bound of behavior policy\u2019s training cost consists of three terms: the cost of teacher policy, the threshold in intervention \u03f5 multiplied by coef\ufb01cients and the superiority of \u03c0b over \u03c0t in cumulative reward. The \ufb01rst two terms are similar to those in Eq. 6 and the third term means a tradeoff between training safety and ef\ufb01cient exploration, which can be adjusted by hyperparameter \u03b7. Comparing the lower bound performance guarantee of action-based and value-based intervention function (Eq. 4 and Eq. 6), the performance gap between \u03c0b and \u03c0t can both be bounded with respect to the threshold for intervention \u03b5 and the discount factor \u03b3. The difference is that the 5 \fPublished as a conference paper at ICLR 2023 performance gap when using Taction is in an order of O( 1 (1\u2212\u03b3)2 ) while the gap with Tvalue is in an order of O( 1 1\u2212\u03b3 ). It implies that in theory value-based intervention leads to better lower-bound performance guarantee. In terms of training safety guarantee, value-based intervention function Tvalue has better safety guarantee by providing a tighter safety bound with the order of O( 1 1\u2212\u03b3 ), in contrast to O( 1 (1\u2212\u03b3)2 ) of action-based intervention function (see Theorem 1 in (Peng et al., 2021)). We show in the Sec. 4.3 that the theoretical advances of Tvalue in training safety and ef\ufb01ciency can both be veri\ufb01ed empirically. 3.3 IMPLEMENTATION Justi\ufb01ed by the aforementioned advantages of the value-based intervention function, we propose a practical algorithm called Teacher-Student Shared Control (TS2C). Its work\ufb02ow is listed in Appendix B. To obtain the teacher Q-network Q\u03c0t in the value-based intervention function in Eq. 5, we rollout the teacher policy \u03c0t and collect training samples during the warmup period. Gaussian noise is added to the teacher\u2019s policy distribution to increase the state coverage during warmup. With limited training data the Q-network may fail to provide accurate estimation when encountering previously unseen states. We propose to use teacher Q-ensemble based on the idea of ensembling Q-networks (Chen et al., 2021). A set of ensembled teacher Q-networks Q\u03c6 with the same architecture and different initialization weights are built and trained with the same data. To learn Q\u03c6 we follow the standard procedure in (Chen et al., 2021) and optimize the following loss: L (\u03c6) = Es,a\u223cD \u0002 y \u2212Mean \u0002 Q\u03c6 (s, a) \u0003\u00032 , (8) where y = Es\u2032\u223cD,a\u2032\u223c\u03c0t(\u00b7|s\u2032)+N (0,\u03c3) \u0002 r + \u03b3Mean \u0002 Q\u03c6 (s\u2032, a\u2032) \u0003\u0003 is the Bellman target and D is the replay buffer for storing sequences {(s, a, r, s\u2032)}. Teacher will intervene when Tvalue returns 1 or the output variance of ensembled Q-networks surpasses the threshold, which means the agent is exploring unknown regions and requires guarding. We also use Q\u03c6 to compute the state-value functions in Eq. 5, leading to the following practical intervention function: TTS2C(s) = \uf8f1 \uf8f4 \uf8f4 \uf8f2 \uf8f4 \uf8f4 \uf8f3 1 if Mean \u0002 Ea\u223c\u03c0t(\u00b7|s)Q\u03c6 (s, a) \u2212Ea\u223c\u03c0s(\u00b7|s)Q\u03c6 (s, a) \u0003 > \u03b51 or Var \u0002 Ea\u223c\u03c0s(\u00b7|s)Q\u03c6 (s, a) \u0003 > \u03b52, 0 otherwise. (9) Eq. 2 shows that the distributional shift and the performance gap to oracle can be reduced with smaller \u03b2, i.e., less teacher intervention. Therefore, we minimize the amount of teacher intervention via adding negative reward to the transitions one step before the teacher intervention. Incorporating intervention minimization, we use the following loss function to update the student\u2019s Q-network parameterized by \u03c8: L(\u03c8) = Es,a\u223cD h\u0000y\u2032 \u2212Q\u03c8 (s, a) \u00012i , (10) where y\u2032 = Es\u2032\u223cD,a\u2032\u223c\u03c0b(\u00b7|s\u2032) \u0002 r \u2212\u03bbTTS2C(s\u2032) + \u03b3Q\u03c8 (s\u2032, a\u2032) \u2212\u03b1 log \u03c0b(a\u2032|s\u2032)] is the soft Bellman target with intervention minimization. \u03bb is the hyperparameter controlling the intervention minimization. \u03b1 is the coef\ufb01cient for maximum-entropy learning updated in the same way as Soft Actor Critic (SAC) (Haarnoja et al., 2018). To update the student\u2019s policy network parameterized by \u03b8, we apply the objective used in SAC as: L(\u03b8) = Es\u223cD \u0002 Ea\u223c\u03c0\u03b8(\u00b7|s) \u0002 \u03b1 log \u0000\u03c0\u03b8 (a | s) \u0001 \u2212Q\u03c8 (s, a) \u0003\u0003 . (11) 4 EXPERIMENTS We conduct experiments to investigate the following questions: (1) Can agents trained with TS2C achieve super-teacher performance with imperfect teacher policies while outperforming other methods in the Teacher-Student Framework (TSF)? (2) Can TS2C provide safety guarantee and improve training ef\ufb01ciency compared to algorithms without teacher intervention? (3) Is TS2C robust in different environments and teacher policies trained with different algorithms? To answer questions (1)(2), we conduct preliminary training with the PPO algorithm (Schulman et al., 2017) and save checkpoints on different timesteps. Policies in different stages of PPO training are used as teacher 6 \fPublished as a conference paper at ICLR 2023 0 0.5 1.0 1.5 2.0 0 50 100 150 200 250 300 350 T est Reward with T eacher-High TS2C Importance EGPO T eacher 0 0.5 1.0 1.5 2.0 0 50 100 150 200 250 300 350 T est Reward with T eacher-Medium 0 0.5 1.0 1.5 2.0 0 50 100 150 200 250 300 350 T est Reward with T eacher-Low 0 0.5 1.0 1.5 2.0 Sampled Steps (1e5) 0 2 4 6 8 10 Training Cost with T eacher-High TS2C Importance EGPO 0 0.5 1.0 1.5 2.0 Sampled Steps (1e5) 0 2 4 6 8 10 12 14 Training Cost with T eacher-Medium 0 0.5 1.0 1.5 2.0 Sampled Steps (1e5) 0 2 4 6 8 10 Training Cost with T eacher-Low Figure 3: Comparison between our method TS2C and other algorithms with teacher policies providing online demonstrations. \u201cImportance\u201d refers to the Importance Advising algorithm. For each column, the involved teacher policy has high, medium, and low performance respectively. policies in TS2C and other algorithms in the TSF. With regard to question (3), we use agents trained with PPO (Schulman et al., 2017), SAC (Haarnoja et al., 2018) and Behavior Cloning as the teacher policies from different sources. 4.1 ENVIRONMENT SETUP The majority of the experiments are conducted on the lightweight driving simulator MetaDrive (Li et al., 2022a). One concern with TSF algorithms is that the student may simply record the teacher\u2019s actions and over\ufb01t the training environment. MetaDrive can test the generalizability of learned agents on unseen driving environments with its capability to generate an unlimited number of scenes with various road networks and traf\ufb01c \ufb02ows. We choose 100 scenes for training and 50 held-out scenes for testing. Examples of the traf\ufb01c scenes from MetaDrive are shown in Appendix C. In MetaDrive, the objective is to drive the ego vehicle to the destination without dangerous behaviors such as crashing into other vehicles. The reward function consists of the dense reward proportional to the vehicle speed and the driving distance, and the terminal +20 reward when the ego vehicle reaches the destination. Training cost is increased by 1 when the ego vehicle crashes or drives out of the lane. To evaluate TS2C\u2019s performance in different environments, we also conduct experiments in several environments of the MuJoCo simulator (Todorov et al., 2012). 4.2 BASELINES AND IMPLEMENTATION DETAILS Two sets of algorithms are selected as baselines to compare with. One includes traditional RL and IL algorithms without the TSF. By comparing with these methods we can demonstrate how TS2C improves the ef\ufb01ciency and safety of training. Another set contains previous algorithms with the TSF, including Importance Advising (Torrey & Taylor, 2013) and EGPO (Peng et al., 2021). The original Importance Advising uses an intervention function based on the range of the Q-function: I(s) = maxa\u2208A QD(s,a) \u2212mina\u2208A QD(s,a), where QD is the Q-table of the teacher policy. Such Q-table is not applicable in the Metadrive simulator with continuous state and action spaces. In practice, we sample N actions from the teacher\u2019s policy distribution and compute their Q-values on a certain state. The intervention happens if the range, i.e., the maximum value minus the minimum value, surpass a certain threshold \u03b5. The EGPO algorithm uses an intervention function similar to the action-based intervention function introduced in section 3.2. All algorithms are trained with 7 \fPublished as a conference paper at ICLR 2023 0 0.5 1.0 1.5 2.0 Sampled Steps (1e5) 0 100 200 300 (a) T est Reward TS2C SAC PPO BC 0 0.5 1.0 1.5 2.0 Sampled Steps (1e5) 0 2 4 6 8 (b) Training Cost 0 0.5 1.0 1.5 2.0 Sampled Steps (1e5) 0.0 0.2 0.4 0.6 0.8 1.0 (c) Average Intervention Rate TS2C EGPO Importance Figure 4: Figures (a) and (b) shows the comparison of ef\ufb01ciency and safety between TS2C and baseline algorithms without teacher policies providing online demonstrations. Figure (c) shows the comparison of the average intervention rate between TS2C and two baseline algorithms in the TSF. 0 0.5 1.0 1.5 2.0 Sampled Steps (1e4) 1500 1250 1000 750 500 250 Test Reward on Pendulum Env TS2C SAC EGPO Teacher 0 1 2 3 4 5 Sampled Steps (1e5) 0 1000 2000 3000 Test Reward on Hopper Env 0 0.2 0.4 0.6 0.8 1.0 Sampled Steps (1e6) 0 1000 2000 3000 4000 Test Reward on Walker2d Env Figure 5: Performance comparison between our method TS2C and baseline algorithms on three environments from MuJoCo. 4 different random seeds. In all \ufb01gures the solid line is computed with the average value across different seeds and the shadow implies the standard deviation. We leave detailed information on the experiments and the result of ablation studies on hyperparameters in Appendix C. 4.3 RESULTS Super-teacher performance and better safety guarantee The training result with three different levels of teacher policy can be seen in Fig. 3. The \ufb01rst row shows that the performance of TS2C is not limited by the imperfect teacher policies. It converges within 200k steps, independent of different performances of the teacher. EGPO and Importance Advicing is clearly bounded by teacher-medium and teacher-low, performing much worse than TS2C with imperfect teachers. The second row of Fig. 3 shows TS2C has lower training cost than both algorithms. Compared to EGPO and Importance Advising, the intervention mechanism in TS2C is better-designed and leads to better behaviors. Better performance with TSF The result of comparing TS2C with baseline methods without the TSF can be seen in Fig. 4(a)(b). We use the teacher policy with a medium level of performance to train the student in TS2C. It achieves better performance and lower training cost than the baseline algorithms SAC, PPO, and BC. The comparative results show the effectiveness of incorporating teacher policies in online training. The behavior cloning algorithm does not involve online sampling in the training process, so it has zero training cost. Extension for different environments and teacher policies The performances of TS2C in different MuJoCo environments and different sources of teacher policy are presented in Fig. 5 and 6 respectively. The \ufb01gures show that TS2C is generalizable to different environments. It can also make use of the teacher policies from different sources and achieve super-teacher performance consistently. Our TS2C algorithm can outperform SAC in all three MuJoCo environments taken into consideration. On the other hand, though the EGPO algorithm has the best performance in the Pendulum environment, it struggles in the other two environments, namely Hopper and Walker. 8 \fPublished as a conference paper at ICLR 2023 0 0.5 1.0 1.5 2.0 Sampled Steps (1e5) 0 100 200 300 T est Reward with PPO T eacher TS2C Importance EGPO T eacher 0 0.5 1.0 1.5 2.0 Sampled Steps (1e5) 0 100 200 300 T est Reward with SAC T eacher 0 0.5 1.0 1.5 2.0 Sampled Steps (1e5) 0 100 200 300 T est Reward with BC T eacher Figure 6: Performance comparison between our method TS2C and baseline algorithms with teacher policies providing online demonstrations. The teacher policies are trained by PPO, SAC, and behavior cloning respectively. 4.4 EFFECTS OF INTERVENTION FUNCTIONS Trajectory with value-based intervention Trajectory with action-based intervention Figure 7: Visualization of the trajectories resulting from different intervention mechanisms. The trajectories of irrelevant traf\ufb01c vehicles are marked orange. As in the green trajectory, action-based intervention make the car following the front vehicle. Valuebased intervention instead can learn overtaking behavior as in blue trajectory. We further investigate the intervention behaviors under different intervention functions. As shown in Fig. 4(c), the average intervention rate Es\u223cd\u03c0b T (s) of TS2C drops quickly as soon as the student policy takes control. The teacher policy only intervenes during a very few states where it can propose actions with higher value than the students. The intervention rate of EGPO remains high due to the action-based intervention function: the teacher intervenes whenever the student act differently. We also show different outcomes of action-based and value-based intervention functions with screenshots in the MetaDrive simulator. In Fig. 7 the ego vehicle happens to drive behind a traf\ufb01c vehicle which is in an orange trajectory. With action-based intervention the teacher takes control and keeps following the front vehicle, as shown in the green trajectory. In contrast, with the value-based intervention the student policy proposes to turn left and overtake the front vehicle as in the blue trajectory. Such action has higher return and therefore is tolerable by TTS2C, leading to a better agent trajectory. 5"
+                }
+            ],
+            "Qingpeng Cai": [
+                {
+                    "url": "http://arxiv.org/abs/2302.01724v3",
+                    "title": "Reinforcing User Retention in a Billion Scale Short Video Recommender System",
+                    "abstract": "Recently, short video platforms have achieved rapid user growth by\nrecommending interesting content to users. The objective of the recommendation\nis to optimize user retention, thereby driving the growth of DAU (Daily Active\nUsers). Retention is a long-term feedback after multiple interactions of users\nand the system, and it is hard to decompose retention reward to each item or a\nlist of items. Thus traditional point-wise and list-wise models are not able to\noptimize retention. In this paper, we choose reinforcement learning methods to\noptimize the retention as they are designed to maximize the long-term\nperformance. We formulate the problem as an infinite-horizon request-based\nMarkov Decision Process, and our objective is to minimize the accumulated time\ninterval of multiple sessions, which is equal to improving the app open\nfrequency and user retention. However, current reinforcement learning\nalgorithms can not be directly applied in this setting due to uncertainty,\nbias, and long delay time incurred by the properties of user retention. We\npropose a novel method, dubbed RLUR, to address the aforementioned challenges.\nBoth offline and live experiments show that RLUR can significantly improve user\nretention. RLUR has been fully launched in Kuaishou app for a long time, and\nachieves consistent performance improvement on user retention and DAU.",
+                    "authors": "Qingpeng Cai, Shuchang Liu, Xueliang Wang, Tianyou Zuo, Wentao Xie, Bin Yang, Dong Zheng, Peng Jiang, Kun Gai",
+                    "published": "2023-02-03",
+                    "updated": "2023-02-12",
+                    "primary_cat": "cs.LG",
+                    "cats": [
+                        "cs.LG",
+                        "cs.IR"
+                    ],
+                    "main_content": "INTRODUCTION As newly emerging media and sharing platforms, short video applications like TikTok, YouTube Shorts, and Kuaishou quickly attract billions of users by recommending interesting content to them. There has been an increasing interest in short video recommendation [12, 16, 27, 33] in academia and industry. In the view of the recommender, a user interacts with the system through explicit and implicit feedback (e.g. watching time, like, follow, comment, etc.) in multiple requests, and the system returns a list of short videos at each request. The ultimate goal is to improve retention, which reflects user satisfaction [30, 32, 37]. User retention is defined as the ratio of visiting the system again, and commonly referred to the retention at next day. It directly affects DAU, which is the core value of the short video app. Current recommender systems deploy point-wise models [6] or list-wise models [23] to recommend items to users. Point-wise models predict the immediate reward of user-item pair, while listwise models estimate the combination of rewards of a list of items considering the positions and relationships between items. Both of them aim at predicting a point-wise reward or a combination of point-wise rewards. However, retention reward is a long-term feedback after multiple interactions between users and the system. Similar to Go game [25], the relationship between retention reward arXiv:2302.01724v3  [cs.LG]  12 Feb 2023 \fWWW\u201923, April 30 May 4, 2023, Austin, Texas, USA Cai, Liu, et al. and the intermediate feedback is not clear, and it is difficult to decompose retention reward to each item or a list of items. Thus traditional models are not able to optimize retention. Reinforcement learning (RL) [26] methods are designed to learn a policy to maximize the long-term reward by interacting with the environment. Thus in this paper we choose RL methods to optimize retention. We model the problem of optimizing user retention in short video systems as an infinite horizon request-based Markov Decision Process (MDP), where the recommender is the agent, and users serve as the environments. The session starts when the user visits the app. At each step (the user\u2019s request), the agent plays an action (the ranking weight) to ensemble scores from scoring models that predict various user feedback. The ensemble ranking function inputs both the ranking weight and the prediction scores, outputs videos with highest scores to the user. Then the user provides immediate feedback including watch time and other interactions. The session ends when the user leaves the app, the next session starts when the user opens the app again and the process repeats. Our objective is to minimize the cumulative returning time (defined as the time gap between the last request of the session and the first request of the next session), which is equal to improving the frequency of user visits, i.e. app open frequency. And the frequency of user visits directly corresponds to retention. Different from previous RL for recommender system works [1, 3\u20135, 9, 11, 17\u201321, 28, 31, 34\u201337] that maximizes the cumulative immediate feedback, we are one of the first works to directly optimize user retention in short video recommender systems to the best of our knowledge. However, current RL algorithms can not be trivially applied due to the following properties of retention reward: 1) Uncertainty: retention is not totally decided by the recommendation algorithm, and is usually affected by many uncertain factors outside the system. For example, retention is disturbed by the noise of social events. 2) Bias: retention is biased with the different factors including time and the level of user\u2019s activity. The retention varies between weekdays and weekends, and highly active users inherently have high retention. 3) Long delay time: different from the instant reward signal in games, the retention reward returns mostly in several hours. It causes the instability of the training of RL policy due to huge distribution shifts [14]. For the uncertainty problem, we propose a novel normalization technique that predicts the returning time and use it to reduce the variance of the retention reward. For the bias problem, we train different policies over user groups to prevent the learning from being dominated by high active users. For the long delay time problem, we propose a novel soft regularization method to better balance the sample efficiency and stability. We also take the immediate feedback as the heuristic rewards and the intrinsic motivation methods [2, 22] to better optimize user retention in the delayed reward setting. Combining the above techniques, we propose the Reinforcement Learning for User Retention algorithm, named as RLUR. We summarize our contributions as below: \u2022 We model the user retention for short video recommendation problem as an infinite horizon requested-based MDP, and the aim is to minimize the cumulative returning time. \u2022 We propose novel methods to solve the challenges of uncertainty, bias, and long delay time of user retention. \u2022 Experiments on both offline and live environments show that RLUR improves user retention significantly. \u2022 The RLUR algorithm has been fully launched in Kuaishou app, and it shows that RLUR continuously improves user retention and DAU. 2 PROBLEM DEFINITION We model the problem as an infinite horizon request-based Markov Decision Process (MDP), where the recommender is the agent, and users are the environments. As shown in Figure 1(a), when the user opens the app, a session \ud835\udc56starts. At each request (step) \ud835\udc56\ud835\udc61of the session \ud835\udc56, the agent plays an action \ud835\udc4e\ud835\udc56\ud835\udc61given the state \ud835\udc60\ud835\udc56\ud835\udc61of the user. \ud835\udc5bdeep models predict scores \ud835\udc65\ud835\udc57= (\ud835\udc65\ud835\udc571, ...,\ud835\udc65\ud835\udc57\ud835\udc5b) for each candidate video \ud835\udc57, in terms of various feedback(watch time, follow, like, etc). The ranking function \ud835\udc53inputs the action \ud835\udc4e\ud835\udc56\ud835\udc61and the prediction scores \ud835\udc65\ud835\udc57, and outputs the ranking score \ud835\udc53(\ud835\udc4e\ud835\udc56\ud835\udc61,\ud835\udc65\ud835\udc57) for each video \ud835\udc57. The system recommends top 6 videos with the highest ranking score to the user as shown in Figure 1(b). Then the user provides immediate feedback \ud835\udc3c(\ud835\udc60\ud835\udc56\ud835\udc61,\ud835\udc4e\ud835\udc56\ud835\udc61). The session ends when the user leaves the app. When the user returns to the app again, the next session \ud835\udc56+ 1 starts, and the delayed reward(returning time) of session \ud835\udc56is returned. Then the above process repeats. We now introduce the detail of the MDP. The state \ud835\udc60\ud835\udc56\ud835\udc61consists of user profile, behavior history \ud835\udc62\ud835\udc56\ud835\udc61, request context, and candidate video features. The action is a continuous vector in [0,\ud835\udc36]\ud835\udc5b, where\ud835\udc5b is the number of scoring models. We use a linear ranking function, i.e, \ud835\udc53(\ud835\udc4e\ud835\udc56\ud835\udc61,\ud835\udc65\ud835\udc57) = \u00cd\ud835\udc5b \ud835\udc58=1 \ud835\udc4e\ud835\udc56\ud835\udc61\ud835\udc58\ud835\udc65\ud835\udc57\ud835\udc58. The immediate reward \ud835\udc3c(\ud835\udc60\ud835\udc56\ud835\udc61,\ud835\udc4e\ud835\udc56\ud835\udc61) is defined as the sum of watch time and the number of interactions at this request. The returning time\ud835\udc47(\ud835\udc60\ud835\udc56) is the time gap between the last request of session \ud835\udc60\ud835\udc56and the first request of session \ud835\udc60\ud835\udc56+1. The returning time reward \ud835\udc5f(\ud835\udc60\ud835\udc56\ud835\udc61,\ud835\udc4e\ud835\udc56\ud835\udc61) is\ud835\udc47(\ud835\udc60\ud835\udc56) for the last request, and 0 otherwise. We learn a deterministic policy \ud835\udf0b(\ud835\udc60\ud835\udc56\ud835\udc61|\ud835\udf03) that inputs the state \ud835\udc60\ud835\udc56\ud835\udc61and outputs the action \ud835\udc4e\ud835\udc56\ud835\udc61. The objective is to minimize the cumulative returning time \u00cd\u221e \ud835\udc56=1 \ud835\udefe\ud835\udc56\u22121\ud835\udc47(\ud835\udc60\ud835\udc56), where \ud835\udefe(0 < \ud835\udefe< 1) is the discount factor. 3 METHOD In this section we firstly discuss the learning of retention in the delayed reward setting. Then we propose techniques to tackle these challenges incurred by the characteristic of user retention. 3.1 Retention Critic Learning In this section we discuss how to learn the retention. We learn a critic function \ud835\udc44\ud835\udc47(\ud835\udc60\ud835\udc56\ud835\udc61,\ud835\udc4e\ud835\udc56\ud835\udc61|\ud835\udc64\ud835\udc47) parameterized by \ud835\udc64\ud835\udc47, to estimate the cumulative returning time from the current state \ud835\udc60\ud835\udc56\ud835\udc61and action \ud835\udc4e\ud835\udc56\ud835\udc61. We follow the deep deterministic policy gradient method [15] to estimate the cumulative returning time reward. As shown in Figure 1(d), the loss function \ud835\udc3f(\ud835\udc64\ud835\udc47) for learning returning time is \u2211\ufe01 \ud835\udc60\ud835\udc56\ud835\udc61,\ud835\udc4e\ud835\udc56\ud835\udc61\u2208\ud835\udc37 (\ud835\udc44\ud835\udc47(\ud835\udc60\ud835\udc56\ud835\udc61,\ud835\udc4e\ud835\udc56\ud835\udc61|\ud835\udc64\ud835\udc47)\u2212(\ud835\udc5f(\ud835\udc60\ud835\udc56\ud835\udc61,\ud835\udc4e\ud835\udc56\ud835\udc61)+\ud835\udefe\ud835\udc56\ud835\udc61\ud835\udc44\ud835\udc47(\ud835\udc60\ud835\udc56\ud835\udc61+1, \ud835\udf0b(\ud835\udc60\ud835\udc56\ud835\udc61+1 |\ud835\udf03)|\ud835\udc64\ud835\udc47)))2, (1) where the discount factor\ud835\udefe\ud835\udc56\ud835\udc61is 1 for samples that are not the last requests and\ud835\udefefor the last requests, and \ud835\udc37is the dataset. The discount \fReinforcing User Retention in a Billion Scale Short Video Recommender System WWW\u201923, April 30 May 4, 2023, Austin, Texas, USA a) MDP Rec Sys 6videos Sampled  Action Sampled  Return Time Reward  Function Retention  Critic Sampled  State Retention  Critic Sampled  Next State Actor Next Action Retention  reward next d) Retention critic learning of RLUR Sampled  Action Sampled  Immediate  Response Reward  Function I Critic Sampled  State I Critic Sampled  Next State Actor Next Action Immediate  reward next RND Sampled  History Intrinsic  reward e) Immediate response critic learning of RLUR Sampled  State Actor Retention  Critic c) Actor training of RLUR Action I Critic Open/Return App Session i starts Request (step) t Immeidate response . . . . . . Leave App Session i ends Return App Session i+1 starts . . . Returning  Time Profile &  history Request context Candidate video  features Request State Candidate  items Action Predicted  scores of  videos Ranking  score Actor Selector 6 videos Scoring  Models b) Inference of RLUR Figure 1: The infinite horizon request-based MDP and the framework of RLUR factor of non-terminal samples is set as 1 to prevent the returning time reward from vanishing by the exponential decay mechanism. If one set the discount factor to be a number less than 1, the importance of returning time in future sessions will be extremely small. Optimizing the loss (1) is equivalent to estimate \u00cd\u221e \ud835\udc56=1 \ud835\udefe\ud835\udc56\u22121\ud835\udc47(\ud835\udc60\ud835\udc56). We omit the proof due to lack of space. 3.2 Methods for Delayed Reward The returning time reward only occurs at the end of each session, and it is inefficient to learn an RL policy with delayed rewards. For better learning of user retention, we adopt the heuristic reward methods [13] to enhance the policy learning and the intrinsic motivation methods [2, 22] to drive the policy to explore novel states. As the feedback and returning time are positively correlated, we take the immediate rewards as heuristic rewards to guide the policy to improve the user retention. For better exploration, we choose the Random Network Distillation (RND) [2] method that is both effective and computationally efficient. The idea is that we randomly initialize two networks with the same structure, and train one network to fit the output of another fixed network. The loss of RND is \ud835\udc3f(\ud835\udc64\ud835\udc52) = \u00cd \ud835\udc62\ud835\udc56\ud835\udc61\u2208\ud835\udc37||\ud835\udc38(\ud835\udc62\ud835\udc56\ud835\udc61|\ud835\udc64\ud835\udc52) \u2212\ud835\udc38(\ud835\udc62\ud835\udc56\ud835\udc61|\ud835\udc64\u2217 \ud835\udc52)||2 2, where \ud835\udc38is the embedding function of behavior history \ud835\udc62\ud835\udc56\ud835\udc61, \ud835\udc64\ud835\udc52is the parameter, and \ud835\udc64\u2217 \ud835\udc52is the fixed parameter. Intuitively, the loss of each state decreases with more samples. Thus it can quantify the novelty of each state. We use the RND loss of each sample as the intrinsic reward. To reduce the interference of immediate rewards with the retention reward, we learn a separate critic function, the immediate reward critic \ud835\udc44\ud835\udc3c(\ud835\udc60\ud835\udc56\ud835\udc61,\ud835\udc4e\ud835\udc56\ud835\udc61|\ud835\udc64\ud835\udc3c) to estimate the sum of the intrinsic rewards with the immediate rewards, \ud835\udc5f\ud835\udc3c(\ud835\udc60\ud835\udc56\ud835\udc61,\ud835\udc4e\ud835\udc56\ud835\udc61) = \ud835\udc3c(\ud835\udc60\ud835\udc56\ud835\udc61,\ud835\udc4e\ud835\udc56\ud835\udc61) + ||\ud835\udc38(\ud835\udc62\ud835\udc56\ud835\udc61|\ud835\udc64\ud835\udc52) \u2212\ud835\udc38(\ud835\udc62\ud835\udc56\ud835\udc61|\ud835\udc64\u2217 \ud835\udc52)||2 2. The loss of the immediate reward critic, \ud835\udc3f(\ud835\udc64\ud835\udc3c) is similar to Eq.(1), shown in Figure 1(e). 3.3 Uncertainty The returning time is highly uncertain and affected by many factors outside the system. To reduce its variance , we now propose a normalization technique. We use the ratio of the true returning time over the predicted returning time as the normalized retention reward. For predicting the returning time, we learn a session-level classification model \ud835\udc47\u2032 to predict the returning probability. We firstly calculate the empirical distribution of returning time, then use the \ud835\udefd% percentile of the distribution, \ud835\udc47\ud835\udefdto determine whether the sample \ud835\udc65is positive or negative. The label \ud835\udc66of sample \ud835\udc65is positive if the returning time is less than \ud835\udc47\ud835\udefdas the shorter time means the better. The loss function of \ud835\udc47\u2032 is \ud835\udc66\u2217\ud835\udc59\ud835\udc5c\ud835\udc54\ud835\udc47\u2032(\ud835\udc65) + (1 \u2212 \ud835\udc66) \u2217\ud835\udc59\ud835\udc5c\ud835\udc54(1 \u2212\ud835\udc47\u2032(\ud835\udc65)), and \ud835\udc47\u2032(\ud835\udc65) predicts the probability that the returning time is shorter than\ud835\udc47\ud835\udefd. Then we get a lower bound of the expected returning time by the Markov Inequality [29], \ud835\udc38\ud835\udc47(\ud835\udc65) \u2265 \ud835\udc43(\ud835\udc47(\ud835\udc65) \u2265\ud835\udc47\ud835\udefd) \u2217\ud835\udc47\ud835\udefd\u223c(1 \u2212\ud835\udc47\u2032(\ud835\udc65)) \u2217\ud835\udc47\ud835\udefdas the predicted returning time. Thus we get the normalized retention reward, \ud835\udc5f(\ud835\udc60\ud835\udc56\ud835\udc61,\ud835\udc4e\ud835\udc56\ud835\udc61) = \ud835\udc50\ud835\udc59\ud835\udc56\ud835\udc5d{0, \ud835\udc47(\ud835\udc60\ud835\udc56) (1\u2212\ud835\udc47\u2032(\ud835\udc65))\u2217\ud835\udc47\ud835\udefd, \ud835\udefc}, where \ud835\udefcis a positive constant. 3.4 Bias As the returning time of high active users is much shorter than that of low active users, and the habit of these groups are quite different, we learn two separate policies \ud835\udf0b(\u00b7|\ud835\udf03high) and \ud835\udf0b(\u00b7|\ud835\udf03low) for high active group and low active group respectively. As we want to minimize the returning time and maximize the immediate rewards, the loss of the policy \ud835\udf0b(\u00b7|\ud835\udf03high) is a weighted sum of the immediate critic and retention critic, \ud835\udc3f(\ud835\udf03high) = \ud835\udf06\ud835\udc47\ud835\udc44\ud835\udc47(\ud835\udc60\ud835\udc56\ud835\udc61, \ud835\udf0b(\ud835\udc60\ud835\udc56\ud835\udc61|\ud835\udf03high)|\ud835\udc64\ud835\udc47) \u2212\ud835\udf06\ud835\udc3c\ud835\udc44\ud835\udc3c(\ud835\udc60\ud835\udc56\ud835\udc61, \ud835\udf0b(\ud835\udc60\ud835\udc56\ud835\udc61|\ud835\udf03high)|\ud835\udc64\ud835\udc3c), (2) where \ud835\udf06\ud835\udc47, \ud835\udf06\ud835\udc3care positive weights. The loss of the other policy is similar. The learning of Actor is shown in Figure 1(c). 3.5 Tackling the Unstable Training Problem Different from that the reward returns instantly in games, the retention reward returns in several hours to days, which causes a much larger distribution shift between current policy and behavior policy and the instability of the training of RL algorithms in our setting. Regularization methods [7] that adds a behavior cloning loss are proposed to stabilize the training in the off-policy setting. However, we find that this method either fails to stabilize or limits the sample efficiency. To better balance the sample efficiency and the stability, we now propose a novel soft regularization method. The actor loss is defined as exp(max{\ud835\udf06\u2217(\ud835\udc59\ud835\udc5c\ud835\udc54(\ud835\udc5d(\ud835\udc4e\ud835\udc56\ud835\udc61|\ud835\udc60\ud835\udc56\ud835\udc61)) \u2212\ud835\udc59\ud835\udc5c\ud835\udc54(\ud835\udc5d\ud835\udc4f(\ud835\udc4e\ud835\udc56\ud835\udc61|\ud835\udc60\ud835\udc56\ud835\udc61))), 0})\ud835\udc3f(\ud835\udf03), \fWWW\u201923, April 30 May 4, 2023, Austin, Texas, USA Cai, Liu, et al. Table 1: Offline Results Algorithm Returning time\u2193 User retention\u2191 CEM 2.036 0.587 TD3 2.009 0.592 RLUR (naive, \ud835\udefe= 0) 2.001 0.596 RLUR (naive, \ud835\udefe= 0.9) 1.961 0.601 RLUR 1.892 0.618 where \ud835\udf06> 0 is the regularization coefficient, \ud835\udc5d(\ud835\udc4e\ud835\udc56\ud835\udc61|\ud835\udc60\ud835\udc56\ud835\udc61) is the probability density of the Gaussian distribution of the current policy, and \ud835\udc5d\ud835\udc4f(\ud835\udc4e\ud835\udc56\ud835\udc61|\ud835\udc60\ud835\udc56\ud835\udc61) is the probability density of the Gaussian distribution of the behavior policy. The intuition is that samples with higher distribution shift get less weight in the learning, which softly regularizes the learning. \ud835\udf06controls the regularization degree, larger \ud835\udf06 makes a stronger regularization on the actor loss. Note that when \ud835\udf06is 0, we do not make any regularization on the actor loss. 4 OFFLINE EXPERIMENTS We validate the effectiveness of RLUR on a public short video recommendation dataset, KuaiRand [10], which is an unbiased dataset that contains the logs of the interactions of users and the system with multiple sessions. We build a simulator based on this dataset, which includes three parts: the user immediate feedback module that predicts multiple user behaviors; the leave module that predicts whether the user leaves the session or not; and the return module that predicts the probability of returning to the app on day \ud835\udc58\u2208{1, . . . , \ud835\udc3e} after each session. We set \ud835\udc3e= 10. We compare RLUR with a black-box optimization method, the Cross Entropy Method (CEM) [24] that is commonly used for ranking parameter searching and a state of the art reinforcement learning method, TD3 [8]. We evaluate the performance of each algorithm in terms of the averaged returning day (returning time) and averaged retention on the 1st day (user retention) across all user sessions. We train each algorithm until convergence, and we report the averaged performance of the last 50 episodes in Table 1. For both metrics, TD3 outperforms CEM, which demonstrates the effectiveness of reinforcement learning. RLUR outperforms both TD3 and CEM significantly. We also train a variant of RLUR that only contains the part of learning the returning time in Section 3.1, called RLUR (naive). RLUR (naive, \ud835\udefe= 0.9) outperforms RLUR (naive, \ud835\udefe= 0), which shows that it is more reasonable to minimize the cumulative retention of multiple sessions than one session as \ud835\udefe controls the importance of future sessions. RLUR outperforms RLUR (naive, \ud835\udefe= 0.9) substantially, which validates the effectiveness of the proposed techniques for the retention challenge. 5 LIVE EXPERIMENTS We test our proposed RLUR algorithm by live experiments in Kuaishou, a billion-scale short video platform. We compare RLUR with a blackbox optimization baseline that is widely used for ranking parameter searching in recommender systems, CEM [24]. We do not compare TD3 here as the training of TD3 is unstable, which is discussed in Section 3.5. We randomly split users into two buckets, deploy RLUR in the test bucket, and run CEM in the base bucket. We evaluate the performance of algorithms in terms of app open frequency, DAU, user retention at 1st day, and user retention at 7th day. We test algorithms for a long time to get convincing results as DAU and user retention varies between days. Now we introduce the details. Inference and Training. The inference procedure is shown in Figure 1(b). At each user request, the user state is sent to the Actor, and the mean \ud835\udf07and variance \ud835\udf0eare returned. Then the action is sampled from a Gaussian distribution \ud835\udc41(\ud835\udf07, \ud835\udf0e). Then the ranking function calculates the linear product of the action with the predicted scores of each video, and recommends 6 videos with the highest scores to the user. The training of actor is illustrated in Figure 1(c). The actor is trained to minimize the weighted sum of the retention critic and the immediate reward critic, as in Eq.(2). MDP. The state is a vector of user profile, behavior history(user statistics, the id of videos and corresponding feedback of the user in previous 3 requests), request context, and the candidate video features. The user profile covers age, gender, and location. The user statistics include statistics of various feedback. For the action, we choose an 8-dimensional continuous vector ranging in [0, 4]8, and the policy outputs the parameters of eight scoring models predicting the main feedback (watchtime, shortview, longview, like, follow, forward, comment, and personal-page entering). The immediate reward \ud835\udc3c(\ud835\udc60\ud835\udc56\ud835\udc61,\ud835\udc4e\ud835\udc56\ud835\udc61) of each request is designed as the the sum of watch time (in seconds) and interactions (including like, follow, comment, and share) of 6 videos. Hyper-parameters. The discounted factor is 0.95, and 0.95 outperforms other values in our system. The weights in actor loss is set to be 1.0, 1.0. As for the session-level retention model, we choose 60% percentile to determine the label, and the value of upper bound, \ud835\udefcis 3. The regularization coefficient \ud835\udf06is 1.5. Figure 2 plot the comparison results of RLUR with CEM, where the x axis stands for the number of days after deployment, and the y axis shows the percentage performance gap between RLUR and CEM. As we can see, app open frequency which directly reflects the returning time, increases consistently from Day 0 to Day 80 and sharply from Day 80 to Day 100. The app open frequency converges to 0.450% after Day 100. That validates the training of RLUR can consistently increase the retention reward and converges at expected. The user retention at 1st day/7th day and DAU increase slowly with the training from Day 0 to Day 80. From day 80 to day 100, these metrics increases sharply. After day 100, the performance gap of DAU converges to 0.2%, user retention at 1st day converges to 0.053%, and user retention at 7th day converges to 0.063%. Note that 0.01% improvement of user retention and 0.1% improvement of DAU are statistically significant in short video platforms. That is, the performance of RLUR is quite significant. Note that DAU and retention continue to increase. 6"
+                },
+                {
+                    "url": "http://arxiv.org/abs/2302.01680v3",
+                    "title": "Two-Stage Constrained Actor-Critic for Short Video Recommendation",
+                    "abstract": "The wide popularity of short videos on social media poses new opportunities\nand challenges to optimize recommender systems on the video-sharing platforms.\nUsers sequentially interact with the system and provide complex and\nmulti-faceted responses, including watch time and various types of interactions\nwith multiple videos. One the one hand, the platforms aims at optimizing the\nusers' cumulative watch time (main goal) in long term, which can be effectively\noptimized by Reinforcement Learning. On the other hand, the platforms also\nneeds to satisfy the constraint of accommodating the responses of multiple user\ninteractions (auxiliary goals) such like, follow, share etc. In this paper, we\nformulate the problem of short video recommendation as a Constrained Markov\nDecision Process (CMDP). We find that traditional constrained reinforcement\nlearning algorithms can not work well in this setting. We propose a novel\ntwo-stage constrained actor-critic method: At stage one, we learn individual\npolicies to optimize each auxiliary signal. At stage two, we learn a policy to\n(i) optimize the main signal and (ii) stay close to policies learned at the\nfirst stage, which effectively guarantees the performance of this main policy\non the auxiliaries. Through extensive offline evaluations, we demonstrate\neffectiveness of our method over alternatives in both optimizing the main goal\nas well as balancing the others. We further show the advantage of our method in\nlive experiments of short video recommendations, where it significantly\noutperforms other baselines in terms of both watch time and interactions. Our\napproach has been fully launched in the production system to optimize user\nexperiences on the platform.",
+                    "authors": "Qingpeng Cai, Zhenghai Xue, Chi Zhang, Wanqi Xue, Shuchang Liu, Ruohan Zhan, Xueliang Wang, Tianyou Zuo, Wentao Xie, Dong Zheng, Peng Jiang, Kun Gai",
+                    "published": "2023-02-03",
+                    "updated": "2024-01-09",
+                    "primary_cat": "cs.LG",
+                    "cats": [
+                        "cs.LG",
+                        "cs.IR"
+                    ],
+                    "main_content": "INTRODUCTION The surging popularity of short videos has been changing the status quo of social media. Short video consumption has brought in huge business opportunities for organizations. As a result, there has been an increasing interest in optimizing recommendation strategies [Gong et al. 2022; Lin et al. 2022; Wang et al. 2022a; Zhan et al. arXiv:2302.01680v3  [cs.LG]  9 Jan 2024 \fWWW \u201923, May 1\u20135, 2023, Austin, TX, USA Cai, et al. HQNNQY NKMG EQOOGPV EQNNGEV UJCTG (a) (b) Figure 1: An example of a popular short video (TikTok, Kuaishou, etc) platform. 2022] for short video platforms. Users interact with the platform by scrolling up and down and watching multiple videos as shown in Figure 1(a). Users provide multi-dimensional responses at each video. As shown in the left part of Figure 1(b), potential responses from a user after consuming a video include WatchTime (the time spent on watching the video), and several types of interactions: Follow (follow the author of the video), Like (Like this video), Comment (provide comments on the video), Collect (Collect this video), Share (share this video with his/her friends), etc. On the one hand, the main goal of the platform is to optimize the cumulative WatchTime of multiple videos, as WatchTime reflects user attention and is highly related to daily active users (DAU). Recently, a growing literature has focused on applying reinforcement learning (RL) to recommender systems, due to its ability to improve cumulative reward [Afsar et al. 2021; Chen et al. 2019b, 2018; Gao et al. 2022a; Ge et al. 2021; Liu and Yang 2019; Ma et al. 2020; Nemati et al. 2016; Wang et al. 2022b; Xian et al. 2019; Xin et al. 2022; Zhao et al. 2018, 2017; Zou et al. 2019]. In particular, WatchTime , can be effectively cumulatively maximized to increase user spent time across multiple videos with RL approaches. On the other hand, other responses such as Like/Follow/Share also reflect user satisfaction levels. Thus the platform needs to satisfy the constraints of user interactions. Thereby, established recommender systems that exclusively optimize a single objective (such as gross merchandise volume for e-commerce platforms [Pi et al. 2020]) is no longer sufficient\u2014the applied systems should take all aspects of responses into consideration to optimize user experiences. In this paper, we model the problem of short video recommendation as a Constrained Markov Decision Process: users serve as the environments, and the recommendation algorithm is the agent; at each time step the agent plays an action (recommend a video to the user), the environment sends multiple rewards (responses) to the agent. The objective of the agent is to maximize the cumulative WatchTime (main goal) subject to the constraints of other interaction responses (auxiliary goals). Our aim is different from Pareto optimality that aims to find a Pareto optimal solution [Chen et al. 2021; Lin et al. 2019; Sener and Koltun 2018], which may not prioritize the main goal of the system. The problem of this constrained policy optimization is much more challenging as compared to its unconstrained counterpart. A natural idea would be applying standard constrained reinforcement learning algorithms that maximize the Lagrangian with prespecified multipliers [Tessler et al. 2018]. However, such method can not apply to our setting for the following two reasons: First, it is not sufficient to use a single policy evaluation model to estimate the Lagrangian dual objective due to different types of responses from the user. Such response combination is not adequate, particularly for responses with their own discount factors\u2014the formulation of temporal difference error in value-based models only allows for a single discount value. In scenarios where one discount factor suffices, it can still be difficult for a single value model to evaluate the policy accurately, especially when different responses are observed at various frequencies, as typical for short video recommendations. The WatchTime response is dense and observed from each video view, while the interaction-signal such as Like/Follow/Share is much more sparse and may not be provided within dozens of views. The signal from the sparse responses will be weakened by the dense responses when naively summing them up together. To address this multi-response evaluation difficulty, we separately evaluate each response via its own value model, which allows for response-specific discount factors and mitigates the interference on evaluation from one response on another. Experiments in Section 4.1 validates the effectiveness of this method. Second, different from only one constraint is considered in [Tessler et al. 2018], multiple constraints exist in recommender systems, especially in short video systems. We find that it is more difficult for algorithms that maximize the Lagrangian to optimize due to larger search space of multi-dimensional Lagrangian multipliers. It is time costly to grid search on the Lagrangian multipliers as the training of reinforcement learning algorithms takes long time. On account of this, we propose to firstly learn policies to optimize each auxiliary response and then \u201csoftly\u201d regularize the policy of the main response to be close to others instead of searching optimal value of Lagrangian multipliers. We theoretically prove the closed form of the optimal solution. We demonstrate empirically that our approach can better maximize the main response and balance other responses in both offline and live experiments. Together, we summarize our contributions as below: \u2022 Constrained Optimization in Short Video Recommendations: We formalize the problem of constrained policy learning in short video recommendations, where different responses may be observed at various frequencies, and the agent maximizes one with the constraint of balancing others. \u2022 Two-Stage Constrained Actor-Critic Algorithm We propose a novel two-stage constrained actor-critic algorithm that effectively tackles the challenge: (1) Multi-Critic Policy Estimation: To better evaluate policy on multiple responses that may differ in discount factors and observation frequencies, we propose to separately learn a value model to evaluate each response. (2) Two-Stage Actor Learning: We propose a \fTwo-Stage Constrained Actor-Critic for Short Video Recommendation WWW \u201923, May 1\u20135, 2023, Austin, TX, USA two-stage actor learning method which firstly learns a policy to optimize each auxiliary response and secondly softly regularizes the policy of the main response to be not far from others, which we demonstrate to be a more effective way in constrained optimization with multiple constraints as compared with other alternatives. \u2022 Significant Gains in Offline and Live Experiments: We demonstrate the effectiveness of our method in both offline and live experiments. \u2022 Deployment in real world short video application: We fully launch our method in a popular short video platform. 2 RELATED WORK Reinforcement Learning for Recommendation. There is a growing literature in applying RL to recommender systems, for its ability to optimize user long-term satisfaction [Afsar et al. 2021]. Value-based approaches estimate user satisfaction of being recommended an item from the available candidate set and then select the one with the largest predicted satisfaction [Chen et al. 2018; Liu and Yang 2019; Nemati et al. 2016; Zhao et al. 2018]. Policy-based methods directly learn the policy (which item to recommend) and optimize it in the direction of increasing user satisfaction [Chen et al. 2019b,a; Ma et al. 2020; Xian et al. 2019]. Recently, growing attention has been paid to adapting reinforcement learning for more complex recommendation applications beyond optimizing one single objective, such as promoting equal exposure opportunities for content items [Ge et al. 2021], increasing diversity and novelty of recommendations [Stamenkovic et al. 2021], and characterizing more comprehensive user dynamics with representational reward shaping [Chen et al. 2021]; we view our work as complementary to the third line. In face of the multi-faceted user responses, the system in real applications often has preferences on different types of user responses, for which we propose the constrained optimization problem in contrast to pursuing the Pareto optimality as proposed in [Chen et al. 2021] and [Ge et al. 2022]. Constrained Reinforcement Learning. Our work is also closely related to the literature of constrained reinforcement learning, where the sequential decision making problem is formulated into a constrained Markov Decision Process [Sutton and Barto 2018], and the policy learning procedure is expected to respect the constraints[Chow et al. 2017; Dalal et al. 2018; Garc\u0131a and Fern\u00e1ndez 2015; Liu et al. 2021; Tessler et al. 2018]. As an example, [Tessler et al. 2018] propose to update the policy and the Lagrangian multiplier alternatively and prove the convergence of their algorithm to a fixed point. This approach however only models one constraint, and can not scale well on problems with multiple constraints. In contrast, for each auxiliary response, we learn a policy to maximize it specifically, then we \u201csoftly\u201d regularize the main policy to be close to others. We show empirically that this is a more effective way for constrained policy learning when dealing with multiple responses in recommender systems. Different from [Nair et al. 2020] that studies in offline RL and regularizes the learned policy to be near to one behavior policy, we softly restrict the policy within other policies maximizing other auxiliary responses. Multi-objective Optimization. We also discuss a relevant line on multi-objective optimization. To trade off different objectives, methods in this field can be broadly categorized into two classes: the Pareto optimization and the joint optimization with pre-specified weights. The goal of Pareto optimization is to find a solution such that no other solutions can concurrently improve all objectives, named as Pareto optimality [Chen et al. 2021; Ge et al. 2022; Nguyen et al. 2020; Sener and Koltun 2018]. However, a Pareto optimal solution may not prioritize the objective that is most valued in applications. The other method combines different objectives together into a single one via pre-specifying the weights [Mossalam et al. 2016; White et al. 1980]. However, it is difficult to quantify these weights that can accurately reflect preferences in real applications [Tessler et al. 2018]. 3 CONSTRAINED MARKOV DECISION PROCESS FOR SHORT VIDEO RECOMMENDATION Figure 2: The MDP of short video recommendation. We start by formulating the problem of short video recommendation, which is shown in Figure 2. When a user \ud835\udc62opens the app, a new session starts. A session consists of multiple requests. At each request \ud835\udc61the recommender system (agent) takes an action \ud835\udc4e\ud835\udc61 that recommends the user a video based on the user current state. Then the user provides multi-faceted responses (such as WatchTime, Like, Share, and Follow) on the shown video, which are received by the agent as vector-valued reward signal. After the user leaves the app, the session ends. The goal of the recommender system is to optimize cumulative reward of the main response (e.g., WatchTime), with the constraint of not sacrificing others much. We model the above procedure as a Constrained Markov Decision Process (CMDP) [Sutton and Barto 2018] (\ud835\udc46,\ud835\udc34, \ud835\udc43, \ud835\udc45,\ud835\udc36, \ud835\udf0c0, \u0393), where \ud835\udc46is the state space of user current representation \ud835\udc60\ud835\udc61, \ud835\udc34is the action space (and each action \ud835\udc4e\ud835\udc61corresponds to a recommended video for one request), \ud835\udc43: \ud835\udc46\u00d7 \ud835\udc34\u2192\u0394(\ud835\udc46) captures the state transition, \ud835\udc45: \ud835\udc46\u00d7\ud835\udc34\u2192R\ud835\udc5adefines the vector-valued reward function that yields \ud835\udc5adifferent rewards \ud835\udc5f(\ud835\udc60\ud835\udc61,\ud835\udc4e\ud835\udc61) = \u0000\ud835\udc5f1(\ud835\udc60\ud835\udc61,\ud835\udc4e\ud835\udc61), . . . ,\ud835\udc5f\ud835\udc5a(\ud835\udc60\ud835\udc61,\ud835\udc4e\ud835\udc61)\u0001, \ud835\udf0c0 is the initial state distribution, \u0393 = (\ud835\udefe1, . . . ,\ud835\udefe\ud835\udc5a) \u2208(0, 1)\ud835\udc5adenotes the vector of discount factor for reward of each response.\ud835\udc36specifies the constraints on the auxiliary responses, which denotes the lower bound of the total numbers of signals of other objectives. Define the vector-valued discounted cumulative reward \ud835\udc45\ud835\udc61as \ud835\udc45\ud835\udc61= \u00cd\ud835\udc47 \ud835\udc61\u2032=\ud835\udc61\u0393\ud835\udc61\u2032\u2212\ud835\udc61\u00b7 \ud835\udc5f(\ud835\udc60\ud835\udc61\u2032,\ud835\udc4e\ud835\udc61\u2032), where \ud835\udc47is the session length (i.e., the number of requests), \u0393\ud835\udc4f= \u0000\ud835\udefe\ud835\udc4f 1, . . . ,\ud835\udefe\ud835\udc4f \ud835\udc5a \u0001, and x \u00b7 y denotes the pointwise product. Let \ud835\udc49\ud835\udf0b(\ud835\udc60) = \u0000\ud835\udc49\ud835\udf0b 1 (\ud835\udc60), . . . ,\ud835\udc49\ud835\udf0b \ud835\udc5a(\ud835\udc60)\u0001 be the state value \fWWW \u201923, May 1\u20135, 2023, Austin, TX, USA Cai, et al. \ud835\udc38\ud835\udf0b[\ud835\udc45\ud835\udc61|\ud835\udc60\ud835\udc61= \ud835\udc60] under actions sampled in accordance with policy \ud835\udf0band \ud835\udc44(\ud835\udc60,\ud835\udc4e) = \u0000\ud835\udc44\ud835\udf0b 1 (\ud835\udc60,\ud835\udc4e), . . . ,\ud835\udc44\ud835\udf0b \ud835\udc5a(\ud835\udc60,\ud835\udc4e)\u0001 be its state-action value \ud835\udc38\ud835\udf0b[\ud835\udc45\ud835\udc61|\ud835\udc60\ud835\udc61= \ud835\udc60,\ud835\udc4e\ud835\udc61= \ud835\udc4e]. Denote \ud835\udf0c\ud835\udf0bas the state distribution induced by policy \ud835\udf0b. Without loss of generality, we set the first response as our main response. The goal is to learn a recommendation policy \ud835\udf0b(\u00b7|\ud835\udc60) to solve the following optimization problem: max \ud835\udf0b \ud835\udc38\ud835\udf0c\ud835\udf0b \u0002 \ud835\udc49\ud835\udf0b 1 (\ud835\udc60) \u0003 s.t. \ud835\udc38\ud835\udf0c\ud835\udf0b \u0002 \ud835\udc49\ud835\udf0b \ud835\udc56(\ud835\udc60) \u0003 \u2265\ud835\udc36\ud835\udc56, \ud835\udc56= 2, . . . ,\ud835\udc5a (1) where \ud835\udc36\ud835\udc56is constraint on the auxiliary response \ud835\udc56. 4 TWO-STAGE CONSTRAINED ACTOR-CRITIC In this section, we propose a novel two-stage constrained actorcritic method, addressing the learning challenges in the context of short video recommendation: Multi-Critic Policy Estimation We propose to estimate the responses separately to better estimate dense and sparse signals. Stage One For each auxiliary response, we learn a policy to optimize its cumulative reward. Stage Two For the main response, we learn a policy to optimize its cumulative reward, while softly limiting it to be close to other policies that are learned to optimize the auxiliary. We first discuss the advantage of evaluating different policies separately over estimating jointly. Secondly, we elaborate our method in the settings of online learning with stochastic policies in Sections 4.2 and 4.3. We then discuss its extensions to the offline setting and deterministic policies. 4.1 Multi-Critic Policy Estimation We showcase the advantage of separate evaluation for each response over a joint evaluation of summed response. Specifically, we consider two types of responses from each video view: WatchTime and interactions (which is an indicator function of whether the interactions happen during the view). \u2022 For the joint evaluation, we learn a value model \ud835\udc49\ud835\udc57\ud835\udc5c\ud835\udc56\ud835\udc5b\ud835\udc61with reward as a sum of WatchTime and interactions. \u2022 For the separate evaluation, we learn two value models \ud835\udc49\ud835\udc64 and \ud835\udc49\ud835\udc56with reward as WatchTime and interactions respectively. Define the value of separate evaluation as \ud835\udc49\ud835\udc60\ud835\udc52\ud835\udc5d\ud835\udc4e\ud835\udc5f\ud835\udc4e\ud835\udc61\ud835\udc52= \ud835\udc49\ud835\udc64+ \ud835\udc49\ud835\udc56 For fair comparison, we share the same discount factor 0.95 for all value models and train them on the same data collected from a popular short video platform for one day. To evaluate the accuracy of the value model in terms of WatchTime and interactions, we compute the correlation between model values \ud835\udc49\ud835\udc57\ud835\udc5c\ud835\udc56\ud835\udc5b\ud835\udc61and \ud835\udc49\ud835\udc60\ud835\udc52\ud835\udc5d\ud835\udc4e\ud835\udc5f\ud835\udc4e\ud835\udc61\ud835\udc52with the Monte Carlo value of the sum of the corresponding responses in each session. As compared to \ud835\udc49\ud835\udc57\ud835\udc5c\ud835\udc56\ud835\udc5b\ud835\udc61, \ud835\udc49\ud835\udc60\ud835\udc52\ud835\udc5d\ud835\udc4e\ud835\udc5f\ud835\udc4e\ud835\udc61\ud835\udc52is more correlated with WatchTime and interactions by 0.19% and 0.14% respectively(a 0.1% improvement on WatchTime and interactions is significant), demonstrating that the separate evaluation better learns different reward responses than jointly learning. 4.2 Stage One: Policy Learning for Auxiliary Responses At this stage, we learn policies to optimize the cumulative reward of each auxiliary response separately. For completeness, we write out our procedure for stochastic policies [Williams 1992]. Considering response \ud835\udc56, let the learned actor and the critic be parameterized by \ud835\udf0b\ud835\udf03\ud835\udc56and \ud835\udc49\ud835\udf19\ud835\udc56respectively. At iteration \ud835\udc58, we observe sample (\ud835\udc60,\ud835\udc4e,\ud835\udc60\u2032) collected by \ud835\udf0b\ud835\udf03(\ud835\udc58) \ud835\udc56 , i.e., \ud835\udc60\u223c\ud835\udf0c\ud835\udf0b\ud835\udf03(\ud835\udc58) \ud835\udc56 ,\ud835\udc4e\u223c\ud835\udf0b\ud835\udf03(\ud835\udc58) \ud835\udc56 (\u00b7|\ud835\udc60) and \ud835\udc60\u2032 \u223c\ud835\udc43(\u00b7|\ud835\udc60,\ud835\udc4e). We update the critic to minimize the Bellman equation: \ud835\udf19(\ud835\udc58+1) \ud835\udc56 \u2190arg min \ud835\udf19\ud835\udc38\ud835\udf0b\ud835\udf03(\ud835\udc58) \ud835\udc56 h\u0000\ud835\udc5f\ud835\udc56(\ud835\udc60,\ud835\udc4e) + \ud835\udefe\ud835\udc56\ud835\udc49\ud835\udf19(\ud835\udc58) \ud835\udc56 (\ud835\udc60\u2032) \u2212\ud835\udc49\ud835\udf19(\ud835\udc60)\u00012i . (2) We update the actor to maximize the advantage: \ud835\udf03(\ud835\udc58+1) \ud835\udc56 \u2190arg max \ud835\udf03 \ud835\udc38\ud835\udf0b\ud835\udf03(\ud835\udc58) \ud835\udc56 h \ud835\udc34(\ud835\udc58) \ud835\udc56 log \u0000\ud835\udf0b\ud835\udf03(\ud835\udc4e|\ud835\udc60)\u0001i where \ud835\udc34(\ud835\udc58) \ud835\udc56 = \ud835\udc5f\ud835\udc56(\ud835\udc60,\ud835\udc4e) + \ud835\udefe\ud835\udc56\ud835\udc49\ud835\udf19(\ud835\udc58) \ud835\udc56 (\ud835\udc60\u2032) \u2212\ud835\udc49\ud835\udf19(\ud835\udc58) \ud835\udc56 (\ud835\udc60). (3) 4.3 Stage Two: Softly Constrained Optimization of the Main Response After pre-training the policies \ud835\udf0b\ud835\udf032, . . . , \ud835\udf0b\ud835\udf03\ud835\udc5athat optimize the auxiliary responses, we now move onto the second stage of learning the policy to optimize the main response. We propose a new constrained policy optimization method with multiple constraints. Let the actor and the critic be \ud835\udf0b\ud835\udf031 and \ud835\udc49\ud835\udf191 respectively. At iteration \ud835\udc58, we similarly update the critic to minimize the Bellman equation: \ud835\udf19(\ud835\udc58+1) 1 \u2190arg min \ud835\udf19\ud835\udc38\ud835\udf0b\ud835\udf03(\ud835\udc58) 1 h\u0000\ud835\udc5f1(\ud835\udc60,\ud835\udc4e) + \ud835\udefe1\ud835\udc49\ud835\udf19(\ud835\udc58) 1 (\ud835\udc60\u2032) \u2212\ud835\udc49\ud835\udf19(\ud835\udc60)\u00012i . (4) The principle of updating the actor is two-fold: (i) maximizing the advantage; (ii) restricting the policy to the domain that is not far from other policies. The optimization is formalized below: max \ud835\udf0b \ud835\udc38\ud835\udf0b[\ud835\udc34(\ud835\udc58) 1 ] s.t. \ud835\udc37\ud835\udc3e\ud835\udc3f(\ud835\udf0b||\ud835\udf0b\ud835\udf03\ud835\udc56) \u2264\ud835\udf16\ud835\udc56, \ud835\udc56= 2, . . . ,\ud835\udc5a, where \ud835\udc34(\ud835\udc58) 1 = \ud835\udc5f1(\ud835\udc60,\ud835\udc4e) + \ud835\udefe1\ud835\udc49\ud835\udf19(\ud835\udc58) 1 (\ud835\udc60\u2032) \u2212\ud835\udc49\ud835\udf19(\ud835\udc58) 1 (\ud835\udc60). (5) We get the closed form solution of the Lagrangian of Eq. (5) in the following theorem. We omit the proof due to lack of space, please refer to Appendix A. Theorem 1. The Lagrangian of Eq. (5) has the closed form solution \ud835\udf0b\u2217(\ud835\udc4e|\ud835\udc60) \u221d \ud835\udc5a \u00d6 \ud835\udc56=2 \u0000\ud835\udf0b\ud835\udf03\ud835\udc56(\ud835\udc4e|\ud835\udc60)\u0001 \ud835\udf06\ud835\udc56 \u00cd\ud835\udc5a \ud835\udc57=2 \ud835\udf06\ud835\udc57exp \u0012 \ud835\udc34(\ud835\udc58) 1 \u00cd\ud835\udc5a \ud835\udc57=2 \ud835\udf06\ud835\udc57 \u0013 , (6) where \ud835\udf06\ud835\udc56with \ud835\udc56= 2, . . . ,\ud835\udc5aare Lagrangian multipliers. Given data collected by \ud835\udf0b\ud835\udf03(\ud835\udc58) 1 , we learn the policy \ud835\udf0b\ud835\udf031 by minimizing its KL divergence from the optimal policy \ud835\udf0b\u2217: \ud835\udf03(\ud835\udc58+1) 1 \u2190arg min \ud835\udf03 \ud835\udc38\ud835\udf0b\ud835\udf03(\ud835\udc58) 1 [\ud835\udc37\ud835\udc3e\ud835\udc3f(\ud835\udf0b\u2217(\ud835\udc4e|\ud835\udc60)||\ud835\udf0b\ud835\udf03(\ud835\udc4e|\ud835\udc60))] = arg max \ud835\udf03 \ud835\udc38\ud835\udf0b\ud835\udf03(\ud835\udc58) 1 h \u00ce\ud835\udc5a \ud835\udc56=2 \u0010 \ud835\udf0b\ud835\udf03\ud835\udc56(\ud835\udc4e|\ud835\udc60) \u0011 \ud835\udf06\ud835\udc56 \u00cd\ud835\udc5a \ud835\udc57=2 \ud835\udf06\ud835\udc57 \ud835\udf0b\ud835\udf03(\ud835\udc58) 1 (\ud835\udc4e|\ud835\udc60) exp \u0012 \ud835\udc34(\ud835\udc58) 1 \u00cd\ud835\udc5a \ud835\udc57=2 \ud835\udf06\ud835\udc57 \u0013 log \ud835\udf0b\ud835\udf03(\ud835\udc4e|\ud835\udc60) i . (7) \fTwo-Stage Constrained Actor-Critic for Short Video Recommendation WWW \u201923, May 1\u20135, 2023, Austin, TX, USA The procedure of the two-stage constrained actor-critic algorithm is shown in Appendix B, and we name it as TSCAC for short. We here provide some intuition behind actor updating in (7). The term \ud835\udf0b\ud835\udf03\ud835\udc56(\ud835\udc4e|\ud835\udc60) denotes the probability the action selected by policy \ud835\udc56and serves as an importance, which softly regularizes the learned policy \ud835\udf0b\ud835\udf031 to be close to other policies \ud835\udf0b\ud835\udf03\ud835\udc56. Smaller Lagrangian multipliers \ud835\udf06\ud835\udc56indicate weaker constraints, and when \ud835\udf06\ud835\udc56= 0, we allow the learned policy \ud835\udf0b\ud835\udf031 to be irrelevant of the constraint policy \ud835\udf0b\ud835\udf03\ud835\udc56. Note that we set the value of \ud835\udf06to be the same, which is more practical for the production system. The performance of TSCAC would be better if we fine-tune it with different Lagrangian multiplier value. But the effectiveness of TSCAC with the same value of \ud835\udf06is validated in both offline and live experiments, as we will see in following sections. Offline Learning We now discuss adapting our constrained actor-critic method to the offline setting, i.e., a fixed dataset. The main change when moving from the online learning to the offline learning is the bias correction on the policy gradient. The actor is no longer updated on data collected by current policy but by another behavior policy \ud835\udf0b\ud835\udefd, which may result in a different data distribution induced by the policy being updated. To address the distribution mismatch when estimating the policy gradient, a common strategy is to apply bias-correction ratio via importance sampling [Precup 2000; Precup et al. 2001]. Given a trajectory \ud835\udf0f= (\ud835\udc601,\ud835\udc4e1,\ud835\udc602,\ud835\udc4e2, . . . ), the bias-correction ratio on the policy gradient for policy \ud835\udf0b\ud835\udf03\ud835\udc56is \ud835\udc64(\ud835\udc60\ud835\udc61,\ud835\udc4e\ud835\udc61) = \u00ce\ud835\udc61 \ud835\udc61\u2032=1 \ud835\udf0b\ud835\udf03\ud835\udc56(\ud835\udc60\ud835\udc61\u2032 |\ud835\udc4e\ud835\udc61\u2032 ) \ud835\udf0b\ud835\udefd(\ud835\udc60\ud835\udc61\u2032 |\ud835\udc4e\ud835\udc61\u2032 ) , which gives an unbiased estimation, but the variance can be huge. Therefore, we suggest using a firstorder approximation, and using the current action-selection ratio when optimizing the actors of auxiliary responses, \ud835\udf03(\ud835\udc58+1) \ud835\udc56 \u2190arg max \ud835\udf03 \ud835\udc38\ud835\udf0b\ud835\udefd \u0014\ud835\udf0b\ud835\udf03(\ud835\udc58) \ud835\udc56 (\ud835\udc4e|\ud835\udc60) \ud835\udf0b\ud835\udefd(\ud835\udc4e|\ud835\udc60) \ud835\udc34(\ud835\udc58) \ud835\udc56 log(\ud835\udf0b\ud835\udf03(\ud835\udc4e|\ud835\udc60)) \u0015 . (8) When updating the actor of the main response, we have \ud835\udf03(\ud835\udc58+1) 1 \u2190arg max \ud835\udf03 \ud835\udc38\ud835\udf0b\ud835\udefd h \u00ce\ud835\udc5a \ud835\udc56=2 \u0010 \ud835\udf0b\ud835\udf03\ud835\udc56(\ud835\udc4e|\ud835\udc60) \u0011 \ud835\udf06\ud835\udc56 \u00cd\ud835\udc5a \ud835\udc57=2 \ud835\udf06\ud835\udc57 \ud835\udf0b\ud835\udefd(\ud835\udc4e|\ud835\udc60) \u00d7 exp \u0012 \ud835\udc34(\ud835\udc58) 1 \u00cd\ud835\udc5a \ud835\udc57=2 \ud835\udf06\ud835\udc57 \u0013 log(\ud835\udf0b\ud835\udf03(\ud835\udc4e|\ud835\udc60)) i . (9) Deterministic Policies We now discuss the extension of TSCAC to deterministic policies[Lillicrap et al. 2015], inspired by the updating rule for the actor of constrained policy discussed in (7). Similarly, at stage one, for each auxiliary response \ud835\udc56, we learn separate critic models \ud835\udc44\ud835\udf19\ud835\udc56(\ud835\udc60,\ud835\udc4e) and actor models \ud835\udf0b\ud835\udf03\ud835\udc56(\ud835\udc60). At stage two, for the main response, we learn critic \ud835\udc44\ud835\udf191 (\ud835\udc60,\ud835\udc4e) via temporal learning, and for actor \ud835\udf0b\ud835\udf031 (\ud835\udc60), the updating rule follows the form: max \ud835\udf03 \ud835\udc5a \u00d6 \ud835\udc56=2 \u0012 \u210e(\ud835\udf0b\ud835\udf03\ud835\udc56(\ud835\udc60), \ud835\udf0b\ud835\udf031 (\ud835\udc60)) \u0013\ud835\udf06\ud835\udc56 \ud835\udc44\ud835\udf191 (\ud835\udc60, \ud835\udf0b\ud835\udf03(\ud835\udc60)), (10) where\u210e(\ud835\udc4e1,\ud835\udc4e2) scores high when two actions\ud835\udc4e1,\ud835\udc4e2 are close to each other and scores low vice versa, and \u210e(\ud835\udf0b\ud835\udf03\ud835\udc56(\ud835\udc60), \ud835\udf0b\ud835\udf031 (\ud835\udc60)) scores high when the actions selected by policy \ud835\udf0b\ud835\udf031 and \ud835\udf0b\ud835\udf03\ud835\udc56are close. \ud835\udf06\ud835\udc56\u22650 plays a similar role as the constraint Lagrangian multiplier\u2014larger \ud835\udf06\ud835\udc56denotes stronger constraint. As an example, given \ud835\udc5bdimensional Table 1: The statistics of KuaiRand. Dimension Number Sparse Ratio users 26858 items 10,221,515 samples 68,148,288 click 25,693,008 37.70% like 1094434 1.61% comment 163977 0.24% hate 32449 0.048% action space, one can choose \u210e(\ud835\udc4e1,\ud835\udc4e2) = \u00cd\ud835\udc5b \ud835\udc51=1 exp \u0000 \u2212(\ud835\udc4e1\ud835\udc51\u2212\ud835\udc4e2\ud835\udc51)2 2 \u0001. The deterministic version of TSCAC can apply to the setting with continuous actions, such as the embedding of the user preference. 5 OFFLINE EXPERIMENTS In this section, we evaluate our method on a public dataset about short video recommendation via extensive offline learning simulations. We demonstrate the effectiveness of our approach as compared to existing baselines in both achieving the main goal and balancing the auxiliaries. We also test the versatility of our method on another public recommendation dataset, please refer to Appendix C due to lack of space. 5.1 Setup Dataset. We consider a public dataset for short video recommendation named KuaiRand (https://kuairand.com/) [Gao et al. 2022b], which is collected from a famous video-sharing mobile app and suitable for the offline evaluation of RL methods as it is unbiased. This dataset collects not only the overall WatchTime of the videos, but also the interaction behavior of the users including Click, Like, Comment and Hate. The statistics of the dataset are illustrated in Table 1. It shows that Like, Comment, and Hate are sparse signals. Note that Hate is extremely sparse. Logs provided by the same user are concatenated to form a trajectory; we choose top 150 videos that are most frequently viewed. MDP. \u2022 state \ud835\udc60\ud835\udc61: A 1044 dimension vector, which is a concatenation of user features(user property), the last 20 video features viewed by the user(user history) and all the 150 candidate video features(context). \u2022 action \ud835\udc4e\ud835\udc61: the video ID to be recommended currently. \u2022 reward \ud835\udc5f\ud835\udc61: a vector of five scores the user provided for the viewed videos in terms of Click, Like, Comment, Hate, and WatchTime. \u2022 episode: a sequence of users\u2019 video viewing history. \u2022 discount factor \ud835\udefe: 0.99 \u2022 objective: We set the main goal to be maximizing the video WatchTime, and treat others as the auxiliaries. Evaluation. We use the Normalised Capped Importance Sampling (NCIS) approach to evaluate different policies, which is a standard offline evaluation approach for RL methods in recommender systems [Zou et al. 2019]. We also evaluate our method in terms of \fWWW \u201923, May 1\u20135, 2023, Austin, TX, USA Cai, et al. other metrics, please refer to Appendix D. The NCIS score is defined: \ud835\udc41(\ud835\udf0b) = \u00cd \ud835\udc60,\ud835\udc4e\u2208\ud835\udc37\ud835\udc64(\ud835\udc60,\ud835\udc4e)\ud835\udc5f(\ud835\udc60,\ud835\udc4e) \u00cd \ud835\udc60,\ud835\udc4e\u2208\ud835\udc37\ud835\udc64(\ud835\udc60,\ud835\udc4e) ,\ud835\udc64(\ud835\udc60,\ud835\udc4e) = min{\ud835\udc50, \ud835\udf0b(\ud835\udc4e|\ud835\udc60) \ud835\udf0b\ud835\udefd(\ud835\udc4e|\ud835\udc60) }, (11) where \ud835\udc37is the dataset, \ud835\udc64(\ud835\udc60,\ud835\udc4e) is the clipped importance sampling ratio, \ud835\udf0b\ud835\udefddenotes the behavior policy, \ud835\udc50is a positive constant. Baselines. We compare TSCAC with the following baselines. \u2022 BC: A supervised behavior-cloning policy \ud835\udf0b\ud835\udefdto mimic the recommendation policy in the dataset, which inputs the user state and outputs the video ID. \u2022 Wide&Deep [Cheng et al. 2016]: A supervised model which utilizes wide and deep layers to balance both memorization and generalization, which inputs the user state, outputs the item id, and the weight of each sample is set to be the weighted sum of all responses of this item. \u2022 DeepFM [Guo et al. 2017]: a supervised recommendation model which combines deep neural network and factorization machine, which inputs the user state, outputs the item id, and the weight of each sample is set to be the weighted sum of all responses of this item. \u2022 RCPO [Tessler et al. 2018] : A constrained actor-critic approach called reward-constrained policy optimization which optimizes the policy to maximize the Lagrange dual function of the constrained program. Specifically, the reward function is defined as \ud835\udc5f= \ud835\udc5f0 + \u00cd\ud835\udc5b \ud835\udc56=1 \ud835\udf06\ud835\udc56\u2217\ud835\udc5f\ud835\udc56, where \ud835\udc5f0 is main objective, WatchTime and \ud835\udc5f\ud835\udc56denotes other feedback, and \ud835\udf06\ud835\udc56is the Lagrangian Multiplier. \u2022 RCPO-Multi-Critic: We test an improved version of RCPO with multiple critics. We separately learn multiple critic models to evaluate the cumulative rewards of each feedback. Then when optimizing the actor, we maximize a linear combination of critics, weighted by the Lagrangian multipliers. \u2022 Pareto [Chen et al. 2021]: A multi-objective RL algorithm that finds the Pareto optimal solution for recommender systems. \u2022 TSCAC: our two-stage constrained actor-critic algorithm. 5.2 Overall Performance Table 2 presents the performance of different algorithms in terms of five scores. We can see that our TSCAC algorithm significantly outperforms other algorithms including both constrained reinforcement learning and supervised learning methods: for the main goal (WatchTime), TSCAC achieves the highest performance 13.14(2.23%); for the auxiliary goal, TSCAC also ranks highest for 3 out of 4 scores (Click, Like, Comment). Note that TSCAC outperforms BC and RCPO at each dimension. The Pareto algorithm indeed learns a Pareto optimal solution that achieves best performance at Hate, but gets the lowest performance 11.90(\u22127.4%), i.e., it does not satisfy the setting with the main goal to optimize the WatchTime. The RCPO algorithm achieves the second highest performance at WatchTime, 13.07(1.70%), but the score at Hate is the worst as the sparse signals are dominated by dense signals in a single evaluation model. Compared with RCPO, RCPO-Multi-Critic achieves much better score at Hate, which demonstrates the effectiveness of the multi-critic policy estimation method. TSCAC also outperforms RCPO-Multi-Critic at each dimension, which shows that the ability of our two-stage actor learning method to deal with multiple responses. 5.3 Ablation Study We investigate how the value of Lagrangian multiplier affects the performance. As we set the value of \ud835\udf06of all constraints to be the same in the second stage, we vary \ud835\udf06across [1\ud835\udc52\u22121, 1\ud835\udc52\u22122, 1\ud835\udc52\u2212 3, 1\ud835\udc52\u22124, 1\ud835\udc52\u22125] and present performance of TSCAC in terms of all responses. Recall that larger \ud835\udf06denotes stronger constraints of auxiliary responses. Figure 3 shows that with \ud835\udf06increasing, the main goal, WatchTime decreases as the constraints of auxiliary responses become stronger. As shown in Figure 3, the performance of interactions drops with small \ud835\udf061\ud835\udc52\u22125 as the constraints are weak. Interestingly, the performance of interactions also decreases with larger \ud835\udf06, which shows that too strong constraints affect the learning of the policy. The value of 1\ud835\udc52\u22124 achieves the best performance at interactions, and improve WatchTime significantly compared with other baselines. 6 LIVE EXPERIMENTS To demonstrate the effectiveness of our algorithm, we test its performance as well as other alternatives via live experiments in a popular short video platform. Algorithms are embodied in a candidateranking system used in production at a popular short video platform, that is, when a user arrives, these algorithms are expected to rank the candidate videos, and the system will recommend the top video to the user. We show that the proposed TSCAC algorithm is able to learn a policy that maximizes the main goal while also effectively balancing the auxiliary goal, and in particular, we set the main one as maximizing the WatchTime and the auxiliary one as improving the interactions between users and videos. 6.1 Setup Evaluation metrics. We use online metrics to evaluate policy performance. For the main goal, we look at the total amount of time user spend on the videos, referred to as WatchTime. For the auxiliary goal, users can interact with videos through multiple ways, such as sharing the video to friends, downloading it, or providing comments. Here, we focus on the three online metrics associated with the user-video interactions\u2014the total number of Share, Download, Comment interactions. MDP. Following the formulation in Section 3, we present the details of the Constrained MDP for short video recommendation. \u2022 state \ud835\udc60\ud835\udc61: user historical interactions (the list of items recommended to users at previous rounds and corresponding user feedbacks), user property (such as device and location) and the feature (the embeddings and statistics) of candidate videos at time \ud835\udc61. \u2022 action \ud835\udc4e\ud835\udc61: a vector embedding of algorithm-predicted user preferences on different video topics, which determines the actual recommendation action(the video to be recommended) via a ranking function described below: the ranking function: for each candidate video, this function calculates the dot product between the predicted user \fTwo-Stage Constrained Actor-Critic for Short Video Recommendation WWW \u201923, May 1\u20135, 2023, Austin, TX, USA Table 2: Performance of different algorithms on KuaiRand. Algorithm Click\u2191 Like\u2191(e-2) Comment\u2191(e-3) Hate\u2193(e-4) WatchTime\u2191 BC 0.5338 1.231 3.225 2.304 12.85 Wide&Deep 0.5544 1.244 3.344 2.011 12.84 3.86% 1.07% 3.69% \u221212.7% \u22120.08% DeepFM 0.5549\u2217 1.388\u2217 3.310 2.112 12.92 3.95%\u2217 12.76%\u2217 2.64% \u22128.31% 0.53% RCPO 0.5510 1.386 3.628\u2217 2.951 13.07\u2217 3.23% 12.57% 12.5%\u2217 28.1% 1.70%\u2217 RCPO-Multi-Critic 0.5519 1.367 3.413 2.108 13.00 3.41% 11.04% 5.83% \u22128.49% 1.14% Pareto 0.5438 1.171 3.393 0.9915\u2217 11.90 1.87% \u22124.85% 5.22% \u221256.96%\u2217 \u22127.4% TSCAC 0.5570 1.462 3.728 1.870 13.14 4.35% 18.80% 15.6% \u221218.83% 2.23% The number in the bracket stands for the unit of this column; The number in the first row of each algorithm is the NCIS score. The percentage in the second row means the performance gap between the algorithm and the BC algorithm. The numbers with \u2217denote the best performance among all baseline methods in each response dimension. The last row is marked by bold font when TSCAC achieves the best performance at each response dimension. 1e-1 1e-2 1e-3 1e-4 1e-5 0.550 0.552 0.554 0.556 Click 1e-1 1e-2 1e-3 1e-4 1e-5 1.350 1.375 1.400 1.425 1.450 1e 2 Like 1e-1 1e-2 1e-3 1e-4 1e-5 3.2 3.3 3.4 3.5 3.6 3.7 1e 3 Comment 1e-1 1e-2 1e-3 1e-4 1e-5 2.0 2.5 3.0 3.5 1e 4 Hate 1e-1 1e-2 1e-3 1e-4 1e-5 13.0 13.1 13.2 Watchtime Figure 3: Effect of the value of the Lagrangian multiplier on the performance. Figure 4: The workflow of RL in production system. preference vector (\ud835\udc4e\ud835\udc61) and the video embedding (representing its topic and quality) as in [Dulac-Arnold et al. 2015]. Then the video with the largest score is recommended. \u2022 reward \ud835\udc5f\ud835\udc61= (\ud835\udc59\ud835\udc61,\ud835\udc56\ud835\udc61): after each recommendation, the system observes how long the user spent on the video, WatchTime , denoted as \ud835\udc59\ud835\udc61, and whether the user has interacted with the video (Share/Download/Comment), denoted as \ud835\udc56\ud835\udc61. \u2022 episode: a trajectory starts when a user opens the app and ends when the user leaves. \u2022 policy: we choose to learn a Gaussian policy in the live experiments. Specifically, the action \ud835\udc4e\ud835\udc61is sampled from a multivariate Gaussian distribution whose mean and variance are output of the actor model. Workflow. As shown in Figure 4, RL runs as follows: \u2022 Inference When the user comes, the user state are sent to the actor network, the actor network sample action by the Gaussian distribution. Then the ranking function inputs both \fWWW \u201923, May 1\u20135, 2023, Austin, TX, USA Cai, et al. Table 3: Performance comparison of different algorithms with the LTR baseline in live experiments. Algorithm WatchTime Share Download Comment RCPO +0.309% \u22120.707% 0.153% \u22121.313% Interaction-AC +0.117% +5.008% +1.952% \u22120.101% TSCAC +0.379% +3.376% +1.733% \u22120.619% the action and the embedding of candidates, calculates the dot product between the action and the video embeddings as scores, and output the item with the highest score to the user. After that, (state, action, rewards, next state) are saved in the replay buffer. \u2022 Training The actor and the critic networks are trained with a mini-batch (state, action, rewards, next state), sampled from the replay buffer. Compared algorithms. We complement our evaluation with a supervised learning-to-rank (LTR) baseline, which is the default model run on the platform. \u2022 RCPO: Following [Tessler et al. 2018], we define a combined reward \ud835\udc59\ud835\udc61+\ud835\udf06\ud835\udc56\ud835\udc61and learn a policy to maximize the cumulative combined reward with discount factor 0.95, where \ud835\udf06is the Lagrangian multiplier. \u2022 TSCAC: We first learn a policy \ud835\udf0b2 to optimize the auxiliary goal. Then we learn a policy \ud835\udf0b1 to optimize the main goal with the soft constraint that \ud835\udf0b1 is close to \ud835\udf0b2. \u2013 Interaction-AC: At the first stage, we learn a policy \ud835\udf0b2 to maximize the interaction reward, with critic update following (2) and actor update following (3). \u2013 TSCAC At the second stage, we learn a main policy \ud835\udf0b1 to maximize the cumulative reward of WatchTime and softly regularize \ud835\udf0b1 to be close to \ud835\udf0b2, with critic update following (4) and actor update following (7). \u2022 LTR (Baseline): The learning-to-rank model [Liu et al. 2009] that takes user state embedding and video embedding as input and fits the sum of responses. Experimental details. To test different algorithms, we randomly split users on the platform into several buckets. The first bucket runs the baseline LTR model, and the remaining buckets run models RCPO, Interaction-AC, and TSCAC. Models are trained for a couple of days and then are fixed to test performance within one day. 6.2 Results Table 3 shows the performance improvement of algorithm comparison with the LTR baseline regarding metrics WatchTime, Share, Download, and Comment. As we can see, RCPO can learn to improve the WatchTime as compared to the baseline; but interactionsignals are too sparse with respect to WatchTime, such that when combining these responses together, it cannot effectively balance the interaction well. Performance of the Interaction-AC algorithm is as expected: with signal from only the interaction reward, it learns to improve the interaction-related metrics (Share, Download, Comment); such interactions between users and videos also improve Day 1 Day 3 Day 5 Day 7 Day 9 Day 11 0.0 0.1 0.2 0.3 % Watch Time Day 1 Day 3 Day 5 Day 7 Day 9 Day 11 0 2 4 % Share Day 1 Day 3 Day 5 Day 7 Day 9 Day 11 0 1 2 3 % Download Day 1 Day 3 Day 5 Day 7 Day 9 Day 11 1 0 1 % Comment Figure 5: Online performance gap of TSCAC over the LTR baseline of each day. the user WatchTime, since more interesting videos with high potential of invoking interactions are recommended, which optimizes user whole experience. Finally, The TSCAC algorithm achieves the best performance: as compared to RCPO, it has better WatchTime and does much better on interaction metrics, thanks to the effective softly regularization during training that it should not be too far from the Interaction-AC policy. Note that 0.1% improvement of WatchTime and 1% improvement of interactions are statistically significant in the short video platform. That is, the performance improvement of our proposed method over baselines is significant. The universal drop of Comment for all RL methods is due to the natural trade-off between WatchTime and Comment. To understand how the TSCAC algorithm learns to balance the main and auxiliary goal, Figure 5 plots the online performance gap of the second stage over the LTR baseline on both WatchTime and interactions. As shown, the algorithm quickly learns to improve the interaction metrics Share and Comment at the beginning, with the constraint of Interaction-AC policy. Then gradually, the model learns to improve WatchTime over time with sacrificing interactions a little. Note that the live performance of TSCAC outperforms RCPO significantly at each dimension, which demonstrates the effectiveness of our method. 7"
+                },
+                {
+                    "url": "http://arxiv.org/abs/2205.13248v1",
+                    "title": "Constrained Reinforcement Learning for Short Video Recommendation",
+                    "abstract": "The wide popularity of short videos on social media poses new opportunities\nand challenges to optimize recommender systems on the video-sharing platforms.\nUsers provide complex and multi-faceted responses towards recommendations,\nincluding watch time and various types of interactions with videos. As a\nresult, established recommendation algorithms that concern a single objective\nare not adequate to meet this new demand of optimizing comprehensive user\nexperiences. In this paper, we formulate the problem of short video\nrecommendation as a constrained Markov Decision Process (MDP), where platforms\nwant to optimize the main goal of user watch time in long term, with the\nconstraint of accommodating the auxiliary responses of user interactions such\nas sharing/downloading videos.\n  To solve the constrained MDP, we propose a two-stage reinforcement learning\napproach based on actor-critic framework. At stage one, we learn individual\npolicies to optimize each auxiliary response. At stage two, we learn a policy\nto (i) optimize the main response and (ii) stay close to policies learned at\nthe first stage, which effectively guarantees the performance of this main\npolicy on the auxiliaries. Through extensive simulations, we demonstrate\neffectiveness of our approach over alternatives in both optimizing the main\ngoal as well as balancing the others. We further show the advantage of our\napproach in live experiments of short video recommendations, where it\nsignificantly outperforms other baselines in terms of watch time and\ninteractions from video views. Our approach has been fully launched in the\nproduction system to optimize user experiences on the platform.",
+                    "authors": "Qingpeng Cai, Ruohan Zhan, Chi Zhang, Jie Zheng, Guangwei Ding, Pinghua Gong, Dong Zheng, Peng Jiang",
+                    "published": "2022-05-26",
+                    "updated": "2022-05-26",
+                    "primary_cat": "cs.LG",
+                    "cats": [
+                        "cs.LG",
+                        "cs.IR"
+                    ],
+                    "main_content": "Introduction The surging popularity of short videos has been changing the status quo of social media. As of 2021, the monthly active users on TikTok have reached one billion worldwide Tik [[n. d.]]. Such prevalence of short video consumption has brought in huge business opportunities for organizations. As a result, there has been an increasing interest in optimizing recommendation strategies for short video platforms, where user feedback is multifaceted. Potential responses from a user after consuming a video include WatchTime (the time spent on watching the video), and several types of interactions: Share (sharing this video with his/her friends), Download (downloading the video), Comment (providing comments on the video), etc. Thereby, established recommender systems that exclusively optimize a single objective (such as gross merchandise volume for e-commence platforms Pi et al. [2020]) is no longer suf\ufb01cient\u2014the applied systems should take all aspects of responses into consideration to optimize user experiences. In this paper, we present our solution in the context of constrained optimization. As opposed to Pareto optimality that is often applied to study multi-objective strategies Sener and Koltun [2018], Chen et al. [2021], preferences on different objectives are often pre-speci\ufb01ed in real applications. Notably, one main goal for short video platforms is to increase the watch time, which is observed from each video view and widely concerns all users. Besides, watch time re\ufb02ects user attention, which is the scarce resource that companies compete for. Conversely, other responses such as Share/Comment are not mutually exclusive among platforms and thus could be sacri\ufb01ced mildly. On the other hand, platforms have been focusing on optimizing user long-term engagement, which directly drives daily active users (DAU) arXiv:2205.13248v1  [cs.LG]  26 May 2022 \fand thereby the revenue growth. Recently, a growing literature has focused on applying reinforcement learning (RL) to recommender systems, due to its ability to improve cumulative reward Nemati et al. [2016], Zhao et al. [2017, 2018], Chen et al. [2018], Zou et al. [2019], Liu and Yang [2019], Chen et al. [2019b], Xian et al. [2019], Ma et al. [2020], Afsar et al. [2021], Ge et al. [2021]. In particular, watch time, as the dense response, can be effectively cumulatively maximized to increase user spent time across multiple requests with RL approaches Chen et al. [2019a]. Thereby, we propose to learn an RL-based agent that optimizes the main goal (WatchTime), with the constraint of compensating other auxiliary responses (Share, Download, and Comment) with reasonable levels. The problem of this constrained policy learning is much more challenging as compared to its unconstrained counterpart. A natural idea would be learning a value-based or policy-based model that maximizes the Lagrangian with pre-speci\ufb01ed multipliers. However, such method is often dif\ufb01cult to be realized in practice via standard RL methods for the following two reasons. First, it is not suf\ufb01cient to use a single policy evaluation model to estimate the Lagrangian dual objective. As discussed, the agent may receive different types of responses from the user. A straightforward approach is to combine them into a single weighted sum using pre-speci\ufb01ed multipliers, and learn a value-based model such as Q-learning Mnih et al. [2013] to optimize it, as proposed in Stamenkovic et al. [2021]. Such response combination is not adequate, particularly for responses with their own discount factors\u2014the formulation of temporal difference error in value-based models only allows for a single discount value. In scenarios where one discount factor suf\ufb01ces, it can still be dif\ufb01cult for a single value model to evaluate the policy accurately, especially when different responses are observed at various frequencies, as typical for short video recommendations. The WatchTime response is dense and observed from each video view, while the interaction-signal such as Share/Comment is much more sparse and may not be provided within dozens of views. Signal from the sparse responses will be weakened by the dense responses when naively summing them up together. To address this multi-response evaluation dif\ufb01culty, we separately evaluate each response via its own value model, which allows for response-speci\ufb01c discount factors and mitigates the interference on evaluation from one response on another, similar to the procedure conducted in Chen et al. [2021], Tajmajer [2018], Hessel et al. [2019]. As an example, we evaluate the behavior policy on a popular short video platform using data collected real time and \ufb01nd that such separate evaluation improves learning on WatchTime and interaction-signal by 0.191% and 0.143% respectively1; Appendix A elaborates the experimental detail. Second, it is hard for a single policy to balance both dense responses and sparse responses. Learning a sparse response itself is well-known to be problematic\u2014it may take the agent undesirably long to learn something meaningful Florensa et al. [2017], Riedmiller et al. [2018]. Coexistence of both dense and sparse responses exacerbates the learning dif\ufb01culty. In most time, the agent only learns to optimize the policy in the direction of optimizing dense responses, which may negatively affect its learning for sparse responses. On account of this, we propose to \ufb01rstly learn a policy to optimize each auxiliary response and then \u201csoftly\u201d regularize the policy of the main response to be in the neighborhood of others. We demonstrate empirically that our approach can better balance different responses in both simulated data and live experiments. Together, we summarize our contributions as below: \u2022 Constrained Optimization in Short Video Recommendations: We formalize the problem of constrained policy learning in short video recommendations, where different aspects of responses may be observed at various frequencies, and the agent learns to optimize one with the constraint of balancing others. \u2022 Multi-Critic Policy Estimation: To better evaluate policy on multiple responses that may differ in discount factors and observation frequencies, we propose to separately learn a value model to evaluate each response. \u2022 Two-Stage Actor-Critic Learning: We propose a two-stage actor-critic framework which \ufb01rstly learns a policy to optimize each auxiliary response and secondly regularizes the policy of the main response to be not far from others, which we demonstrate to be a more effective way in constrained optimization as compared with other alternatives. \u2022 Gains in Live Experiments: We demonstrate the effectiveness of our approach in live experiments, showing the ability of our approach in optimizing the main response of WatchTime as well as balancing other interaction ones. 1In real applications for video recommendations, an improvement around 0.1% on value estimation is already signi\ufb01cant to be re\ufb02ected in production performance. 2 \f2 Related Work Constrained Reinforcement Learning Our work is also closely related to the literature of constrained reinforcement learning, where the sequential decision making problem is formulated into a constrained Markov Decision Process Sutton and Barto [2018], and the policy learning procedure is expected to respect the constraints. There are mainly two categories of constraints: cumulative ones (sum of a given signal should be limited into certain region) and instantaneous ones (constraints should be satis\ufb01ed at each step) Liu et al. [2021], Perkins and Barto [2002], Garc\u0131a and Fern\u00e1ndez [2015]. To deal with cumulative constraints, there is a large body of literature focusing on Lagrangian relaxation Chow et al. [2017, 2019], Tessler et al. [2018], Dalal et al. [2018]. As an example, Tessler et al. [2018] propose to update the policy and the Lagrangian multiplier alternatively and prove the convergence of their algorithm to a \ufb01x point. This approach however does not deal with the dif\ufb01culty of policy learning on rewards with different observation frequencies and thus is dif\ufb01cult to achieve a good balance among multiple responses. In contrast, for each cumulative reward, we learn a policy to maximize it speci\ufb01cally, then we \u201csoftly\u201d regularize the main policy to be in the neighborhood of others. We show empirically that this is a more effective way for constrained policy learning when dealing with both sparse and dense rewards. Different from Nair et al. [2020] that studies in of\ufb02ine RL and regularizes the learned policy to be in the neighborhood of one behavior policy, we softly restrict the policy within other policies maximizing other auxiliary responses and we do not limit to of\ufb02ine settings. Multi-objective Optimization We also discuss a relevant line on multi-objective optimization. To trade off different objectives, methods in this \ufb01eld can be broadly categorized into two classes: the Pareto optimization and the joint optimization with pre-speci\ufb01ed weights. The goal of Pareto optimization is to \ufb01nd a solution such that no other solutions can concurrently improve all objectives, named as Pareto optimality Nguyen et al. [2020], Sener and Koltun [2018], Chen et al. [2021], ?. However, a Pareto optimal solution may not prioritize the objective that is most valued in applications. The second method combines different objectives together into a single one via pre-specify the weights White et al. [1980], Mossalam et al. [2016]. However, it is dif\ufb01cult to quantify these weights that can accurately re\ufb02ect preferences in real applications Tessler et al. [2018]. 3 Preliminaries 3.1 Constrained Markov Decision Process We start by formulating the problem of short video recommendation on mobile app services. When a user u opens the app, a new session starts. A session consists of multiple requests. At each request t when the user slides down the app, the recommender system (agent) takes an action at that recommends the user a video based on the user current state, characterized by his/her demographics, historical interactions, etc. Then the user provides multi-faceted responses (such as WatchTime, Share, Download, Comment) on the shown video, which are received by the agent as vector-valued reward signal and used for future planning; let m be the number of types of responses. The goal of the recommender system is to optimize cumulative reward of the main response (e.g., WatchTime), with the constraint of not sacri\ufb01cing others much. We model the above procedure as a Constrained Markov Decision Process(CMDP) Sutton and Barto [2018] (S, A, P, R, C, \u03c10, \u0393), where S is the state space of user current representation st, A is the action space (and each action at corresponds to a recommended video for one request), P : S \u00d7 A \u2192\u2206(S) captures the state transition, R : S \u00d7 A \u2192Rm de\ufb01nes the vector-valued reward function that yields m different rewards r(st, at) = \u0000r1(st, at), . . . , rm(st, at) \u0001 , \u03c10 is the initial state distribution, \u0393 = (\u03b31, . . . , \u03b3m) \u2208(0, 1)m denotes the vector of discount factor for reward of each response, and C speci\ufb01es the constraints on the auxiliary responses. De\ufb01ne the vector-valued discounted cumulative reward Rt as Rt = PT t\u2032=t \u0393t\u2032\u2212t \u00b7 r(st\u2032, at\u2032), where T is the session length (i.e., the number of requests), \u0393b = \u0000\u03b3b 1, . . . , \u03b3s m \u0001 , and x \u00b7 y denotes the pointwise product. Let V \u03c0(s) = \u0000V \u03c0 1 (s), . . . , V \u03c0 m(s) \u0001 be the state value E\u03c0[Rt|st = s] under actions sampled in accordance with policy \u03c0 and Q(s, a) = \u0000Q\u03c0 1(s, a), . . . , Q\u03c0 m(s, a) \u0001 be its state-action value E\u03c0[Rt|st = s, at = a]. Denote \u03c1\u03c0 as the state distribution induced by policy \u03c0. Without loss of generality, we set the \ufb01rst response as our main response. The goal is to learn a recommendation policy \u03c0(\u00b7|s) over the action space to solve the following optimization problem: max \u03c0 E\u03c1\u03c0 \u0002 V \u03c0 1 (s) \u0003 s.t. E\u03c1\u03c0 \u0002 V \u03c0 i (s) \u0003 \u2265Ci, i = 2, . . . , m (1) where Ci is constraint on the auxiliary response i. 3 \f4 Two-Stage Constrained Actor Critic In this section, we propose our two-stage constrained policy learning based on actor-critic framework, addressing the learning challenges in the context of dense and sparse rewards: Stage One For each auxiliary response, we learn a policy to optimize its cumulative reward. Stage Two For the main response, we learn a policy to optimize its cumulative reward, while limiting it to be close to other policies that are learned to optimize the auxiliary. We \ufb01rst elaborate our framework in the settings of online learning with stochastic policies (such as A2C and A3C Williams [1992], Mnih et al. [2016]) in Sections 4.1 and 4.2(the procedure is summarized in Appendix C). We then discuss its extensions to deterministic policies (such as DDPG and TD3 Lillicrap et al. [2015], Fujimoto et al. [2018]). For of\ufb02ine setting, please refer to Appendix D. 4.1 Stage One: Policy Learning for Auxiliary Responses At this stage, we learn policies to optimize the cumulative reward of each auxiliary response separately. For completeness, we write out our procedure following the standard advantage actor critic approach Williams [1992]. Considering response i, let the learned actor and the critic be parameterized by \u03c0\u03b8i and V\u03c6i respectively. At iteration k, we observe sample (s, a, s\u2032) collected by \u03c0\u03b8(k) i , i.e., s \u223c\u03c1\u03c0 \u03b8(k) i , a \u223c\u03c0\u03b8(k) i (\u00b7|s) and s\u2032 \u223cP(\u00b7|s, a). We update the critic to minimize the Bellman equation: \u03c6(k+1) i \u2190arg min \u03c6 E\u03c0 \u03b8(k) i h\u0000ri(s, a) + \u03b3iV\u03c6(k) i (s\u2032) \u2212V\u03c6(s) \u00012i . (2) We update the actor to maximize the advantage: \u03b8(k+1) i \u2190arg max \u03b8 E\u03c0 \u03b8(k) i h A(k) i log \u0000\u03c0\u03b8(a|s) \u0001i where A(k) i = ri(s, a) + \u03b3iV\u03c6(k) i (s\u2032) \u2212V\u03c6(k) i (s). (3) 4.2 Stage Two: Constrained Optimization of the Main Response After pretraining the policies \u03c0\u03b82, . . . , \u03c0\u03b8m that optimize the auxiliary responses, we now move onto the second stage of learning the policy to optimize the main response. We propose a new constrained advantage actor critic approach. Let the actor and the critic be \u03c0\u03b81 and V\u03c61 respectively. At iteration k, we similarly update the critic to minimize the Bellman equation: \u03c6(k+1) 1 \u2190arg min \u03c6 E\u03c0 \u03b8(k) 1 h\u0000r1(s, a) + \u03b31V\u03c6(k) 1 (s\u2032) \u2212V\u03c6(s) \u00012i . (4) The principle of updating the actor is two-fold: (i) maximizing the advantage; (ii) restricting the policy to the domain that is not far from other policies. The optimization is formalized below: max \u03c0 E\u03c0[A(k) 1 ] s.t. DKL(\u03c0||\u03c0\u03b8i) \u2264\u03f5i, i = 2, . . . , m, where A(k) 1 = r1(s, a) + \u03b31V\u03c6(k) 1 (s\u2032) \u2212V\u03c6(k) 1 (s). (5) Equation (5) has the closed form solution \u03c0\u2217(a|s) \u221d m Y i=2 \u0000\u03c0\u03b8i(a|s) \u0001 \u03bbi Pm j=2 \u03bbj exp \u0012 A(k) 1 Pm j=2 \u03bbj \u0013 , (6) where \u03bbi with i = 2, . . . , m are Lagrangian multipliers for constraints in (5), and the value of \u03bbi controls the degree of constraint. Given data collected by \u03c0\u03b8(k) 1 , we learn the policy \u03c0\u03b81 by minimizing its KL divergence from the optimal policy \u03c0\u2217: \u03b8(k+1) 1 \u2190arg min \u03b8 E\u03c0 \u03b8(k) 1 [DKL(\u03c0\u2217(\u00b7|s)||\u03c0\u03b8(\u00b7|s))] = arg max \u03b8 E\u03c0 \u03b8(k) 1 h m Y i=2 \u0010 \u03c0\u03b8i(a|s) \u03c0\u03b8(k) 1 (a|s) \u0011 \u03bbi Pm j=2 \u03bbj exp \u0012 A(k) 1 Pm j=2 \u03bbj \u0013 log \u03c0\u03b8(a|s) i . (7) 4 \fAppendix B contains the derivation details. We here provide some intuition behind actor updating in (7). The ratio \u03c0\u03b8i(a|s) \u03c0 \u03b8(k) 1 (a|s) suggests that the updating direction of policy \u03c0\u03b81 will be favored when it\u2019s aligned with the constraint policies \u03c0\u03b8i, which effectively regularizes the learned policy \u03c0\u03b81 to be in the neighborhood of other policies \u03c0\u03b8i. Small Lagrangian multipliers \u03bbi indicate weaker constraints, and when \u03bbi = 0, we allow the learned policy \u03c0\u03b81 to be irrelevant of the constraint policy \u03c0\u03b8i. Deterministic Policies We now shed light on adaptation of our framework to deterministic policies such as deep deterministic policy gradient (DDPG) algorithm Lillicrap et al. [2015], inspired by the updating rule for the actor of constrained policy discussed in (7). Similarly, at stage one, for each auxiliary response i, we learn the actor \u03c0\u03b8i(s) and critic Q\u03c6i(s, a) via DDPG algorithm respectively. At stage two, for the main response, we learn critic Q\u03c61(s, a) via temporal learning; and for actor \u03c0\u03b81(s), the updating rule follows the form of max \u03b81 m Y i=2 \u0012h(a, \u03c0\u03b8i(s)) h(a, \u03c0\u03b8i(s)) \u0013 \u03bb1 Pm j=2 \u03bbj f \u0012Q\u03c61(s, \u03c0(s)) Pm j=2 \u03bbj \u0013 , (8) where f is an increasing function which pushes the gradient of \u03c0\u03b81 towards increasing the policy value; h(a1, a2) scores high when two actions a1, a2 are close to each other and scores low vice versa; \u03bbi \u22650 plays the same role as the constraint Lagrangian multiplier in (7)\u2014larger \u03bbi denotes stronger constraint. As a demonstration, one can choose f to be the identity function and h(a1, a2) = exp \u0000\u2212(a1\u2212a2)2 2 \u0001 . Section 5 showcases how this construction of softly constrained DDPG algorithm effectively achieves the main goal as well as balancing the auxiliaries. 5 Of\ufb02ine Experiments In this section, we evaluate our approach on a public dataset via extensive of\ufb02ine learning simulations. We demonstrate the effectiveness of our approach as compared to existing baselines in both achieving the main goal and balancing the auxiliaries. 5.1 Setup Dataset We consider a hotel-review dataset named TripAdvisor, which is a standard dataset for studying policy optimization in recommender system with multiple responses in Chen et al. [2021]. In this data, customers not only provide an overall rating for hotels but also score hotels in multiple aspects including service, business, cleanliness, check-in, value, rooms, and location Alam et al. [2016]. 2 Reviews provided by the same user are concatenated chronologically to form a trajectory; we \ufb01lter trajectories with length smaller than 20. In total, we have 20277 customers, 150 hotels, and 257932 reviews. MDP A trajectory tracks a customer hotel-reviewing history. For each review, we have state st: customer ID and the last three reviewed hotel IDs as well as corresponding multi-aspect review scores; action at: currently reviewed hotel ID; reward rt: a vector of eight scores the customer provided for the reviewed hotel in terms of service, business, cleanliness, check-in, value, rooms, location, and overall rating; discount factor \u03b3: 0.99. We set the main goal to be maximizing the cumulative overall rating, and treat others as the auxiliaries. Evaluation We use the Normalised Capped Importance Sampling ((NCIS) approach to evaluate different policies, which is a standard of\ufb02ine evaluation method in literature Swaminathan and Joachims [2015]. Compared algorithms We compare our approach with a range of recommendation algorithms. \u2022 BC: a supervised behavior-cloning policy \u03c0\u03b2 to mimic customer reviewing pattern, with input as the user state and output as the reviewed hotel ID. \u2022 Wide&DeepCheng et al. [2016]: a supervised model which utilizes wide and deep layers to balance both memorization and generalization, with input as the user state, output as the reviewed hotel id, and sample weight as the weighted sum of 8 scores for this review. \u2022 A3CMnih et al. [2016]: an online RL approach with one actor and one critic, where reward is the weighted sum of 8 scores for a given customer-hotel review. 2The dataset consists of both the main objective and other responses, which can also be used to evaluate constrained policy optimization in recommender system. 5 \fAlgorithm BC Wide&Deep A3C DDPG RCPO Pareto Constrained Service 3.38 3.41\u2217 3.37 3.4 3.41 3.36 3.43 Business \u22121.86 \u22121.86 \u22121.78\u2217 \u22121.82 \u22121.82 \u22121.79 -1.82 Cleanliness 3.57 3.62\u2217 3.56 3.61 3.62\u2217 3.57 3.64 Check-in \u22120.73 \u22120.75 \u22120.65 \u22120.71 \u22120.68 \u22120.62\u2217 \u22120.68 Value 3.32 3.36\u2217 3.27 3.34 3.35 3.29 3.37 Rooms 2.92 2.96 2.97\u2217 2.95 2.97\u2217 2.93 3.00 Location 2.93\u2217 2.88 2.88 2.91 2.87 2.86 2.98 Overall Rating 3.92 3.98 3.94 3.97 3.99\u2217 3.95 3.99 Table 1: Performance of different algorithms on an of\ufb02ine dataset. The results with \u2217denote the best performance among all baseline methods in each response dimension, and the data in last column is marked by bold font when our constrained-DDPG achieves the best performance. \u2022 DDPGLillicrap et al. [2015]: an of\ufb02ine RL approach with one actor and one critic, where reward is the weighted sum of 8 scores for a given customer-hotel review. \u2022 RCPO: an of\ufb02ine RL approach that extends the reward-constrained policy optimization of A3C algorithm in Tessler et al. [2018] to DDPG algorithm. Contrary to the standard DDPG, we learn eight critics for the eight scores and use Lagrangian multipliers to sum them up for the actor optimization. \u2022 Pareto: a recommendation model based on DDPG algorithm to \ufb01nd the Pareto optimal solution for multiobjective optimization. \u2022 Constrained (Ours): our constrained actor critic approach based on DDPG algorithm, where the construction follows the discussion in Section 4.2. We note that we use DDPG instead of A3C as the base actor critic model to develop constrained policy optimization (RCPO, Pareto, and Ours), by the nature of of\ufb02ine learning. As a comparison, we also present the performance of A3C, which is for online learning and thus is outperformed by DDPG on this dataset\u2014as we shall see shortly. 5.2 Overall Performance Table 1 presents the results of different algorithms in terms of eight scores. First note that A3C is outperformed by DDPG in most scores, which is as expected since A3C is an online learning algorithm that does not \ufb01t the of\ufb02ine setup here; this justi\ufb01es our comparison focusing on DDPG-based constrained RL algorithms. We can see that our approach Constrained-DDPG performs the best among all algorithms: for the main goal, Constrained-DDPG achieves the highest overall rating 3.99; for the auxiliary goal, Constrained-DDPG also ranks highest for 5 out of 7 scores (service, cleanliness, value, rooms, location). The Pareto algorithm indeed learns a Pareto-optimal solution that achieves best performance on the check-in score, which however does not satisfy the setting here with the main goal to optimize the overall rating. The RCPO algorithm achieves the same best overall score as our approach, but they sacri\ufb01ce much on the others, and in particular, the location score is even lower than that from the BC algorithm. 5.3 Ablation Study The ablation study contains discussing the effect of the Lagrangian multiplier as well as the effect of the discount factor. Due to lack of space, the latter is attached in Appendix E. We investigate how the Lagrangian multiplier, which controls the strength of constraint, affects our model performance. We vary \u03bb across [1e \u22128, 2.56e \u22126, 1e \u22124, 1.6e \u22123, 1, 1e4] and present performance of our constrained-DDPG in terms of all eight scores. Recall that larger \u03bb denotes stronger constraint that optimizes scores other than the overall one. Figure 1 shows that with \u03bb increasing, our policy performance is also improved on most constraint scores (including service, business, cleanliness, value, rooms, and location), which is as expected since the learned policy becomes closer to the constraint policy that optimizes those scores. 6 Live Experiments The ultimate goal of recommender systems is to improve online user experience. To demonstrate the effectiveness of our algorithm, we test its real-world performance as well as other alternatives via A/B experiments. Algorithms are embodied in a candidate-ranking system used in production at a popular short video platform, that is, when a user arrives, these algorithms are expected to rank the candidate videos, and the system will recommend the top video to the 6 \f1e-8 2.56e-6 1e-4 1.6e-3 1 1e4 3.426 3.428 3.430 3.432 Service 1e-8 2.56e-6 1e-4 1.6e-3 1 1e4 1.818 1.817 1.816 1.815 Business 1e-8 2.56e-6 1e-4 1.6e-3 1 1e4 3.634 3.636 3.638 Cleanliness 1e-8 2.56e-6 1e-4 1.6e-3 1 1e4 0.6775 0.6750 0.6725 0.6700 0.6675 0.6650 Check-in 1e-8 2.56e-6 1e-4 1.6e-3 1 1e4 3.366 3.368 3.370 3.372 Value 1e-8 2.56e-6 1e-4 1.6e-3 1 1e4 2.992 2.994 2.996 2.998 Rooms 1e-8 2.56e-6 1e-4 1.6e-3 1 1e4 2.970 2.972 2.974 2.976 2.978 Location 1e-8 2.56e-6 1e-4 1.6e-3 1 1e4 3.980 3.982 3.984 3.986 3.988 3.990 Overall Figure 1: Effect of Lagrangian multiplier on model performance. The X-axis is the of Lagrangian multiplier and the Y-axis is the score of each response. user. We show that the proposed constrained actor-critic model is able to learn a policy that maximizes the main goal while also effectively balancing the auxiliary goal, and in particular, we set the main one as maximizing the watch time and the auxiliary one as improving the interactions between users and videos. 6.1 Setup Evaluation metrics We use online metrics to evaluate policy performance. For the main goal, we look at the total amount of time user spend on the videos, referred to as WatchTime. For the auxiliary goal, users can interact with videos through multiple ways, such as sharing the video to friends, downloading it, or providing comments. Here, we focus on the three online metrics associated with the user-video interactions\u2014the total number of Share, Download, Comment interactions. MDP Following the formulation in Section 3.1, we present the constrained MDP in the context of short video recommendation. A trajectory starts when a user opens the app and ends when the user leaves. At time t, we have \u2022 state st: a vector embedding of user current representation, for which we concatenate embeddings of user historical interactions (encoded by recurrent neural networks) and instantaneous context (such as device and location). \u2022 action at: a vector embedding of algorithm-predicted user preferences on different video topics, which determines the actual recommendation action\u2013the video to be recommended\u2014via a ranking function described below. \u2022 the ranking function: for each candidate video, this function calculates the dot product between the predicted user preference vector (at) and the video embedding (representing its topic and quality). The platform then recommends the video that achieves the largest score. \u2022 reward rt = (lt, it): after each recommendation, the system observes how long the user spent on the video, denoted as lt, and whether the user has interacted with the video (such as sharing/downloading/commenting on it), denoted as it. \u2022 discount factor: we set \u03b3l = 0.95 for the time reward lt and \u03b3i = 0.0 for interaction reward it if not speci\ufb01ed otherwise.3 Compared algorithms We choose A3C Mnih et al. [2016] as the base actor critic model, since algorithms compared are trained online in our live experiment setup, as opposed to the of\ufb02ine learning in Section 5 that uses DDPG as the base actor critic model. Speci\ufb01cally, the action at is sampled from a multivariate Gaussian distribution whose mean and variance are output of the actor model. We also complement our evaluation with a supervised learning-to-rank (LTR) baseline, which is the default model run on the platform. \u2022 A3C: We de\ufb01ne a combined reward mt = lt + \u03bbit and learn a standard A3C Mnih et al. [2016] policy to maximize cumulative mt with discount factor 0.95. 3We \ufb01nd that 0.95 is optimal for optimizing Watch time and 0 is optimal for maximizing the interactions in live experiments. 7 \fAlgorithm WatchTime Share Download Comment A3C +0.309% \u22120.707% 0.153% \u22121.313% RCPO-A3C +0.283% \u22121.075% \u22120.519% \u22120.773% Interaction +0.117% +5.008% +1.952% \u22120.101% Constrained +0.336% +3.324% +1.785% \u22120.618% Table 2: Performance of different algorithms relative to a supervised LTR baseline in a live experiment. \u2022 RCPO-A3C : We separately learn two critic models Vl, Vi to evaluate cumulative time reward lt (with \u03b3l = 0.95) and instant interaction reward it (with \u03b3i = 0). Then when optimizing the actor, we use advantage as a linear combination of advantages calculated from two critic models respectively: At = Al,t + \u03bbAi,t, where Al,t = lt+\u03b3lVl(st+1)\u2212Vl(st), Ai,t = it+\u03b3iVi(st+1)\u2212Vi(st), and \u03bb can be viewed as the Lagrangian multiplier in Tessler et al. [2018] 4. \u2022 Two-Stage constrained A3C (Ours): Following Algorithm 1, we \ufb01rst learn a policy \u03c0i to optimize the auxiliary goal. Then we learn a policy \u03c0d to optimize the main goal with the constraint that \u03c0d is in the neighborhood of \u03c0i. \u2013 Interaction: At the \ufb01rst stage, we learn a A3C policy \u03c0i to maximize instant interaction reward it, with critic update following (2) and actor update following (3). \u2013 Constrained At the second stage, we learn a constrained A3C policy \u03c0d which maximizes the cumulative time reward dt in the neighborhood of policy \u03c0i, with critic update following (4) and actor update following (7). \u2022 LTR (Baseline): The learning-to-rank model? that takes user state embedding and video embedding as input and \ufb01ts the sum of responses. Experimental details To test different algorithms, we randomly split users on the platform into \ufb01ve buckets with splitting ratio being 80%, 5%, 5%, 5%, 5%. The \ufb01rst bucket runs the baseline LTR model, and the remaining buckets run models A3C, RCPO-A3C, Interaction-A3C, and Constrained-A3C respectively. Models are pre-trained online for a couple of days and then are \ufb01xed to concurrently test performance within one day. 6.2 Results Table 2 shows the results of algorithm comparison regarding metrics WatchTime, Share, Download, and Comment. As we can see, both A3C with combined reward and RCPO-A3C with combined advantage learn to improve the WatchTimeas compared to the base model; but interaction-signal is too sparse with respect to WatchTime, such that when combining these two responses together\u2013in the form of either reward or advantage\u2013both models cannot effectively balance the interaction well. Performance of the Interaction model is as expected: with signal from only the interaction reward, the model learns to improve the interaction-related metrics (Share, Download, Comment); such interactions between users and videos also improve the user watch time, since more interesting videos with high potential of invoking interactions are recommended, which optimizes user whole experience. Finally, our model achieves the best performance: as compared to A3C and RCPO-A3C, it has slightly better WatchTimeand does much better on interaction metrics, thanks to the effective regularization during training that it should not be too far from the Interaction-A3C policy. To understand how our Constrained-A3C model learns to balance the main and auxiliary goal, Figure 2 plots its online performance\u2013relative to the LTR baseline\u2013during the learning phase on the two live metrics: WatchTimeand Share. As shown, The model quickly learns to improve the Sharemetric by being restricted to the neighborhood of Interaction-A3C policy, demonstrating the effectiveness of our soft constraint. Then gradually, the model learns to improve WatchTime over time. 7"
+                },
+                {
+                    "url": "http://arxiv.org/abs/2108.04526v3",
+                    "title": "A Survey on Deep Reinforcement Learning for Data Processing and Analytics",
+                    "abstract": "Data processing and analytics are fundamental and pervasive. Algorithms play\na vital role in data processing and analytics where many algorithm designs have\nincorporated heuristics and general rules from human knowledge and experience\nto improve their effectiveness. Recently, reinforcement learning, deep\nreinforcement learning (DRL) in particular, is increasingly explored and\nexploited in many areas because it can learn better strategies in complicated\nenvironments it is interacting with than statically designed algorithms.\nMotivated by this trend, we provide a comprehensive review of recent works\nfocusing on utilizing DRL to improve data processing and analytics. First, we\npresent an introduction to key concepts, theories, and methods in DRL. Next, we\ndiscuss DRL deployment on database systems, facilitating data processing and\nanalytics in various aspects, including data organization, scheduling, tuning,\nand indexing. Then, we survey the application of DRL in data processing and\nanalytics, ranging from data preparation, natural language processing to\nhealthcare, fintech, etc. Finally, we discuss important open challenges and\nfuture research directions of using DRL in data processing and analytics.",
+                    "authors": "Qingpeng Cai, Can Cui, Yiyuan Xiong, Wei Wang, Zhongle Xie, Meihui Zhang",
+                    "published": "2021-08-10",
+                    "updated": "2022-02-04",
+                    "primary_cat": "cs.LG",
+                    "cats": [
+                        "cs.LG",
+                        "cs.AI",
+                        "cs.DB"
+                    ],
+                    "main_content": "Introduction In the age of big data, data processing and analytics are fundamental, ubiquitous, and crucial to many organizations which undertake a digitalization journey to improve and transform their businesses and operations. Data analytics typically entails other key operations such as data acquisition, data cleansing, data integration, modeling, etc., before insights could be extracted. Big data can unleash signi\ufb01cant value creation across many sectors such as healthcare and retail [56]. However, the complexity of data (e.g., high volume, high velocity, and high variety) presents many challenges in data analytics and hence renders the di\ufb03culty in drawing meaningful insights. To tackle the challenge and facilitate the data processing and analytics e\ufb03ciently and e\ufb00ectively, a large number of algorithms and techniques have been designed and numerous learning systems have also been developed by researchers and practitioners such as Spark MLlib [63], and Ra\ufb01ki [106]. To support fast data processing and accurate data analytics, a huge number of algorithms rely on rules that are developed based on human knowledge and experience. For example, shortest-job-\ufb01rst is a scheduling algorithm that chooses the job with the smallest execution time for the next execution. However, without fully exploiting characteristics of the workload, it can achieve inferior performance compared to a learning-based scheduling algorithm [58]. Another example is packet classi\ufb01cation in computer networking which matches a packet to a rule from a set of rules. One solution is to construct the decision \u2217These authors have contributed equally to this work, and M. Zhang is the contact author. 1 arXiv:2108.04526v3  [cs.LG]  4 Feb 2022 \ftree using hand-tuned heuristics for classi\ufb01cation. Speci\ufb01cally, the heuristics are designed for a particular set of rules and thus may not work well for other workloads with different characteristics [47]. We observe three limitations of existing algorithms [97, 46]. First, the algorithms are suboptimal. Useful information such as data distribution could be overlooked or not fully exploited by the rules. Second, the algorithm lacks adaptivity. Algorithms designed for a speci\ufb01c workload cannot perform well in another di\ufb00erent workload. Third, the algorithm design is a time-consuming process. Developers have to spend much time trying a lot of rules to \ufb01nd one that empirically works. Learning-based algorithms have also been studied for data processing and analytics. Two types of learning methods are often used: supervised learning and reinforcement learning. They achieve better performance by direct optimization of the performance objective. Supervised learning typically requires a rich set of high-quality labeled training data, which could be hard and challenging to acquire. For example, con\ufb01guration tuning is important to optimize the overall performance of a database management system (DBMS)[44]. There could be hundreds of tuning knobs that are correlated in discrete and continuous space. Furthermore, diverse database instances, query workloads, hardware characteristics render data collection infeasible, especially in the cloud environment. Compared to supervised learning, reinforcement learning shows good performance because it adopts a trial-and-error search and requires fewer training samples to \ufb01nd good con\ufb01guration for cloud databases [123]. Another speci\ufb01c example would be query optimization in query processing. Database system optimizers are tasked to \ufb01nd the best execution plan for a query to reduce its query cost. Traditional optimizers typically enumerate many candidate plans and use a cost model to \ufb01nd the plan with minimal cost. The optimization process could be slow and inaccurate [42]. Without relying on an inaccurate cost model, deep reinforcement learning (DRL) methods improve the execution plan (e.g., changing the table join orders) by interacting with the database[61, 37]. Figure 1 provides a typical work\ufb02ow for query optimization using DRL. When the query is sent to the agent (i.e., DRL optimizer), it produces a state vector via conducting featurization on essential information, such as the accessed relations and tables. Taking the state as the input, the agent employs neural networks to produce the probability distribution of an action set, where the action set could contain all possible join operations as potential actions. Each action denotes a partial join plan on a pair of tables, and the state will be updated once an action is taken. After taking possible actions, a complete plan is generated, which is then executed by a DBMS to get the reward. In this query optimization problem, the reward can be calculated by the real latency. During the training process with the reward signal, the agent can improve the policy and produce a better join ordering with a higher reward (i.e., less latency). 2 \fDBMS  Engine A B Policy State \ud835\udc60: Featurization ( ) A B C D A.age,   B.age,   C.age,      \u2026 Action Set  a! \ud835\udf0b!(\ud835\udc4e|\ud835\udc60) SQL Query: SELECT * FROM A, B, C, D  WHERE A.age = B.age AND A.age = C.age AND \u2026 \u22c8 A.Age = B.age A C a( \u22c8 A.Age = C.age \u2026 \u2026 Reward \ud835\udc45(\ud835\udc60, \ud835\udc4e) Transition \ud835\udc43(\ud835\udc60!|\ud835\udc60, \ud835\udc4e) Agent (DRL Optimizer) D C B A complete join ordering plan \u22c8 \u22c8 \u22c8 Figure 1: The Work\ufb02ow of DRL for Query Optimization. A, B, C and D are four tables. Reinforcement learning (RL) [89] focuses on learning to make intelligent actions in an environment. The RL algorithm works on the basis of exploration and exploitation to improve itself with feedback from the environment. In the past decades, RL has achieved tremendous improvements in both theoretical and technical aspects [86, 89]. Notably, DRL incorporates deep learning (DL) techniques to handle complex unstructured data and has been designed to learn from historical data and self-exploration to solve notoriously hard and large-scale problems (e.g., AlphaGo[85]). In recent years, researchers from di\ufb00erent communities have proposed DRL solutions to address issues in data processing and analytics[116, 58, 52]. We categorize existing works using DRL from two perspectives: system and application. From the system\u2019s perspective, we focus on fundamental research topics ranging from general ones, such as scheduling, to system-speci\ufb01c ones, such as query optimization in databases. We shall also emphasize how it is formulated in the Markov Decision Process and discuss how the problem can be solved by DRL more e\ufb00ectively compared to traditional methods. Many techniques such as sampling and simulation are adopted to improve DRL training e\ufb03ciency because workload execution and data collection in the real system could be time-consuming [31]. From the application\u2019s perspective, we shall cover various key applications in both data processing and data analytics to provide a comprehensive understanding of the DRL\u2019s usability and adaptivity. Many domains are transformed by the adoption of DRL, which helps to learn domain-speci\ufb01c knowledge about the applications. In this survey, we aim at providing a broad and systematic review of recent advancements in employing DRL in solving data systems, data processing and analytics issues. In Section 3 \f2, we introduce the key concepts, theories, and techniques in RL to lay the foundations. To gain a deeper understanding of DRL, readers could refer to the recently published book [13], which covers selected DRL research topics and applications with detailed illustrations. In Section 3, we review the latest important research works on using DRL for system optimization to support data processing and analytics. We cover fundamental topics such as data organization, scheduling, system tuning, index, query optimization, and cache management. In Section 4, we discuss using DRL for applications in data processing and analytics ranging from data preparation, natural language interaction to various real-world applications such as healthcare, \ufb01ntech, E-commerce, etc. In Section 5, we highlight various open challenges and potential research problems. We conclude in Section 6. This survey focuses on recent advancements in exploring RL for data processing and analytics that spurs great interest, especially in the database and data mining community. There are survey papers discussing DRL for other domains. We refer readers to the survey of DRL for healthcare in [118], communications and networking in [54], and RL explainability in [76]. Another work[107] discusses how deep learning can be used to optimize database system design, and vice versa. In this paper, we use \"DRL\" and \"RL\" interchangeably. 2 Theoretical Foundation and Algorithms of Reinforcement Learning RL is targeted to solve the sequential decision making problem and the goal is to take actions with maximum expected rewards. In detail, the agent follows a policy to make a series of decisions (i.e. taking actions) in di\ufb00erent states of the environment, and the sequence of the states and the actions form a trajectory. To estimate whether the policy is good or not, each decision under the policy will be evaluated by the accumulated rewards through the trajectory. After evaluating the policy from the trajectories, the agent next improves the policy by increasing the probabilities of making decisions with greater expected rewards. By repeating these steps, the agent can improve the policy through trial-and-error until the policy reaches the optimal, and such a sequential decision-making process is modeled via Markov Decision Process (MDP). 2.1 Markov Decision Process Mathematically, MDP, shown in Figure 1, is a stochastic control process M de\ufb01ned by a tuple with 5 elements, M = (S, A, R, P, \u03b3), which are explained as follows. \u2022 State S: S is the space for states that denote di\ufb00erent situations in the environment and st \u2208S denotes the state of the situation at the time t. \u2022 Action A: A is the space for actions that the agent can take; the actions can either be discrete or continuous, and at \u2208A denotes the action taken at the time t. \u2022 Reward function R(st, at): It denotes the immediate reward of the action at taken under the state st. \u2022 Transition function P(st+1 = s\u2032|st = s, at = a): It denotes the probability of transition to the state s\u2032 at the time t + 1 given the current state s and the taken action a at the time t. \u2022 Discount factor \u03b3 \u2208[0, 1]: The total rewards of a certain action consist of both immediate rewards and future rewards, and the \u03b3 quanti\ufb01es how much importance we give for future rewards. 4 \fWe take the query optimization problem demonstrated in Figure 1 to help explain the \ufb01ve components of the MDP. In this example, the state is expressed as a state vector, which summarizes the information of relations and tables that are assessed by the query q. In each state, the RL agent produces a probability distribution over all potential actions where each action denotes a partial join plan on a pair of tables. After repeating these two processes, it reaches a terminal state where the \ufb01nal join ordering is generated for an agent to execute, and all actions\u2019 target rewards are measured by the actual performance (i.e., latency) or a cost model. As for the transition function, the transitions of the states are always deterministic in both this problem and most of the other DB problems. In RL, we aim to train the agent with a good policy \u03c0 that is a mapping function from state to action. Through the policy, the agent can take a series of actions that will result in continuous changes in the states, and the sequence of the states and the actions following the policy \u03c0 form a trajectory \u03c4 = (s0, a0, s1, a1, ...). From each \u03c4, we can evaluate the e\ufb00ect of each action by the accumulated rewards G, and it consists of the immediate reward of this action and the discounted rewards of its following actions in the trajectory. The total result G for the action at is as follows: G(\u03c4) = P t=0 \u03b3trt, where \u03b3 quanti\ufb01es how much importance we give for future rewards. With a bigger \u03b3, the RL agent will be more likely to take any action that may have a less immediate reward at the current time but has a greater future reward in expectation. RL continuously evaluates the policy \u03c0 and improves it until it reaches the optimal policy \u03c0\u2217= arg max(\u03c4\u223c\u03c0) G(\u03c4) where the agent always takes actions that maximize the expected return. To evaluate the policy \u03c0, RL algorithms estimate how good or bad it is for a state and a state-action pair by the function V and function Q respectively. Both of these two value functions are calculated according to the discounted return G in expectation which can be written as: V\u03c0(s) = E\u03c4\u223c\u03c0[G(\u03c4)|s0 = s] (1) Q\u03c0(s, a) = E\u03c4\u223c\u03c0[G(\u03c4)|s0 = s, a0 = a] (2) These two value functions have a close association where the V\u03c0(st) is the expectation of the function Q of all possible actions under the state st according to the policy \u03c0, and the Q\u03c0(st, at) is the combination of the immediate reward of the action at and the expectation of all possible states\u2019 values after taking the action at under the state st. Hence, we have: V\u03c0(s) = X a\u2208A \u03c0(a|s)Q\u03c0(s, a) (3) Q\u03c0(s, a) = R(s, a) + \u03b3 X s\u2032\u2208S P(s\u2032|s, a)V\u03c0(s\u2032) (4) Given a policy \u03c0, we can evaluate its value functions by Bellman equations [89] which utilize the recursive relationships of these value functions. Formally, Bellman equations deduce the relationships between a given state (i.e. function V) or a given state-action pair (i.e. function Q) and its successors which can be written as: V\u03c0(s) = X at\u2208A \u03c0(a|s)[R(s, a) + \u03b3 X s\u2032\u2208S P(s\u2032|s, a)V\u03c0(s\u2032)] (5) 5 \fBasic  Techniques Model-based  Methods Model-free  Methods Dynamic Programming, Alpha Zero, \u2026 Value-based Policy-based SARSA (On-policy) Q-learning (Off-policy) Policy Gradient Actor-Critic Advanced Techniques Data Sampling Model Efficiency Data Utilization Data Correlation Policy Reward Value Policy Exploration Policy Representation Policy Optimization Multiple Reward Unknown Reward Value Representation RL Deep Q-learning DDPG Figure 2: Broad categorization of RL techniques. Q\u03c0(s, a) = X s\u2032\u2208S P(s\u2032|s, a)[R(s, a) + \u03b3 X a\u2032\u2208A \u03c0(a\u2032|s\u2032)Q\u03c0(s\u2032, a\u2032)] (6) By iterating the Bellman equations, we can easily obtain the value functions for a policy, and to compare policies, we de\ufb01ne that the policy \u03c0 is better than \u03c0\u2032 if the function V according to the \u03c0 is no less than the function V according to the \u03c0\u2032 for all states, that is V\u03c0(s) \u2265V\u03c0\u2032(s), \u2200s. It has been proven in [89] that the existence of the optimal policy \u03c0\u2217 is guaranteed in the MDP problem, where V\u2217(s) = max\u03c0 V\u03c0(s) and Q\u2217(s) = max\u03c0 Q\u03c0(s). These two functions are de\ufb01ned as the optimal function V and the optimal function Q. We can obtain the optimal policy \u03c0\u2217by maximizing over the Q\u2217(\u03c0) which can be written as: \u03c0\u2217(a|s) = arg max Q\u2217(s, a) (7) To improve the policy, we apply the Bellman optimality equations [89] to update value functions by taking the action with maximum value instead of trying all possible actions. To facilitate the optimization of the policy, many RL techniques are proposed from di\ufb00erent perspectives, and Figure 2 provides a diagram outlining the broad categorization of these techniques, illustrating how these techniques can be applied. 2.2 Basic Techniques Based on the representation of MDP elements, basic techniques can be categorized into two classes: model-based method and model-free method. The main di\ufb00erence is whether the agent has access to model the environment, i.e. whether the agent knows the transition function and the reward function. These two functions are already known in the modelbased method where Dynamic Programming (DP)[6] and Alpha-Zero [86] are the classical methods which have achieved signi\ufb01cant results in numerous applications. In these methods, agents are allowed to think ahead and plan future actions with known e\ufb00ects on the environment. Besides, an agent can learn the optimal policy from the planned experience which results in high sample e\ufb03ciency. 6 \fIn many RL problems, the reward and the transition function are typically unknown due to the complicated environment and its intricate inherent mechanism. For example, as illustrated in Figure 1, we are unable to obtain the actual latency as the reward in the joint query optimization example. Besides, in the stochastic job scheduling problem [59], it is also impossible to directly model the transition function because of the randomness of the job arrivals in the practical scenarios. Hence, in these problems, agents usually employ model-free methods that can purely learn the policy from the experience gained during the interaction with the environment. Model-free methods can mainly be classi\ufb01ed into two categories, namely the value-based method and the policy-based method. In the value-based method, the RL algorithm learns the optimal policy by maximizing the value functions. There are two main approaches in estimating the value functions that are Mento-Carlo (MC) methods and Temporal di\ufb00erence (TD) methods. MC methods calculate the V(s) by directly applying its de\ufb01nition, that is Equation 1. MC methods can directly update the value functions once they get a new trajectory \u03c4 as follows: V\u03c0(s) \u2190V\u03c0(s) + \u03b1(G\u03c4\u223c\u03c0(\u03c4|s0 = s) \u2212V\u03c0(s)) (8) where \u03b1 \u2208[0, 1) denotes the learning rate which controls the rate of updating the policy with new experiences. However, it has an obvious drawback that a complete trajectory requires the agent to reach a terminal state, while it is not practical in some applications, such as online systems. Di\ufb00erent from MC methods, the TD method builds on the recursive relationship of value functions, and hence, can learn from the incomplete trajectory. Mathematically, the update of TD methods can be written as: V\u03c0(s) \u2190V\u03c0(s) + \u03b1(R(s, a) + \u03b3V\u03c0(s\u2032) \u2212V\u03c0(s)) (9) However, there is bias when estimating the function V with TD methods because they learn from the recursive relationship. To reduce the bias, TD methods can extend the length of the incomplete trajectories and update the function V by thinking more steps ahead, which is called n-steps TD methods. As n grows to the length of whole trajectories, MC methods can be regarded as a special case of TD methods where function V is an unbiased estimate. On the other side of the coin, as the length n increases, the variance of the trajectory also increases. In addition to the above consideration, TD-based methods are more e\ufb03cient and require less storage and computation, thus they are more popular among RL algorithms. In value-based methods, we can obtain the optimal policy by acting greedily via Equation 7. The update of the function Q with TD methods is similar to the update of the function V, and is as follows: Q\u03c0(s, a) \u2190Q\u03c0(s, a) + \u03b1(R(s, a) + \u03b3Q\u03c0\u2032(s\u2032, a\u2032) \u2212Q\u03c0(s, a)) where the agent follows the policy \u03c0 to take actions and follows the policy \u03c0\u2032 to maximize the function Q. If the two policies are the same, that is \u03c0\u2032 = \u03c0, we call such RL algorithms the on-policy methods where the SARSA[77] is the representative method. In addition, other policies can also be used in \u03c0\u2032. For example, in Q-learning[109], the agent applies the greedy policy and updates the function Q with the maximum value in its successor. Its update formula can be written as: Q\u03c0(s, a) \u2190Q\u03c0(s, a)+\u03b1(R(s, a)+\u03b3 maxa\u2032 Q\u03c0(s\u2032, a\u2032)\u2212Q\u03c0(s, a)). Both value-based methods can work well without the model of the environment, and Qlearning directly learns the optimal policy, whilst SARSA learns a near-optimal policy during exploring. Theoretically, Q-learning should converge quicker than SARSA, but its generated samples have a high variance which may su\ufb00er from the problems of converging. In RL, storage and computation costs are very high when there is a huge number of states or actions. To overcome this problem, DRL, as a branch of RL, adopts Deep Neural 7 \fNetwork (DNN) to replace tabular representations with neural networks. For function V, DNN takes the state s as input and outputs its state value V\u03b8(s) \u2248V\u03c0(s) where the \u03b8 denotes the parameter in the DNN. When comes to function Q, It takes the combination of the state s and the action a as input and outputs the value of the state-action pair Q\u03b8(s, a) \u2248Q\u03c0(s, a), As for the neural networks, we can optimize them by applying the techniques that are widely used in deep learning (e.g. gradient descent). Deep Q-learning network (DQN) [65], as a representative method in DRL, combines the DNN with Qlearning and its loss function is as follows: Lw = ED[(R(s, a) + \u03b3 max a\u2217\u2208A Qw(s\u2032, a\u2217) \u2212Qw(s, a))2] (10) where D denotes the experience replay which accumulates the generated samples and can stabilize the training process. Policy-based methods are another branch of the model-free RL algorithm that have a clear representation of the policy \u03c0(a|s), and they can tackle several challenges that are encountered in value-based methods. For example, when the action space is continuous, value-based methods need to discretize the action which could increase the dimensionality of the problem, and memory and computation consumption. Value-based methods learn a deterministic policy that generates the action given a state through an optimal function Q (i.e. \u03c0(s) = a). However, for policy-based methods, they can learn a stochastic policy (i.e. \u03c0\u03b8(ai|s) = pi, P i pi = 1) as the optimal policy, where pi denotes the probability of taking the action ai given a state s, and \u03b8 denotes the parameters where neural networks can be used to approximate the policy. Policy Gradient [90] method is one of the main policybased methods which can tackle the aforementioned challenges. Its goal is to optimize the parameters \u03b8 by using the gradient ascent method, and the target can be denoted in a generalized expression: \u2207\u03b8J(\u03b8) = E\u03c4\u223c\u03c0\u03b8[R(\u03c4)\u2207\u03c0\u03b8 log\u03c0\u03b8(a|s)] (11) The speci\ufb01c proof process can refer to [89]. Sampling via the MC methods, we will get the entire trajectories to improve the policy for the policy-based methods. After training, the action with higher rewards in expectation will have a higher probability to be chosen and vice versa. As for the continuous action, The optimal policy learned from the Policy Gradient is stochastic which still needs to be sampled to get the action. However, the stochastic policy still requires lots of samples to train the model when the search space is huge. Deterministic Policy Gradient (DPG) [87], as an extension of the Policy Gradient, overcomes this problem by using a stochastic policy to perform sampling while applying deterministic policy to output the action which demands relatively fewer samples. Both value-based methods and policy-based methods have their strengths and weaknesses, but they are not contradictory to each other. Actor-Critic (AC) method, as the integration of both methods, divides the model into two parts: actor and critic. The actor part selects the action based on the parameterized policy and the critic part concentrates on evaluating the value functions. Di\ufb00erent from previous approaches, AC evaluates the advantage function A\u03c0(s, a) = Q\u03c0(s, a) \u2212V\u03c0(s) which re\ufb02ects the relative advantage of a certain action a to the average value of all actions. The introduction of the value functions also allows AC to update by step through the TD method, and the incorporation of the policy-based methods makes AC be suitable for continuous actions. However, the combination of the 8 \ftwo methods also makes the AC method more di\ufb03cult to converge. Moreover, Deep Deterministic Policy Gradient (DDPG) [49], as an extension of the AC, absorbs the advanced techniques from the DQN and the DPG which enables DDPG to learn the policy more e\ufb03ciently. In all the above-mentioned methods, there always exists a trade-o\ufb00between exploring the unknown situation and exploiting with learned knowledge. On the one hand, exploiting the learned knowledge can help the model converge quicker, but it always leads the model into a local optimal rather than a globally optimal. On the other hand, exploring unknown situations can \ufb01nd some new and better solutions, but always being in the exploring process causes the model hard to converge. To balance these two processes, researchers have been devoting much energy to \ufb01nding a good heuristics strategy, such as \u03f5 \u2212greedy strategy, Boltzmann exploration (Softmax exploration), upper con\ufb01dence bound (UCB) algorithm [2], Thompson sampling [92], and so on. Here, we consider the \u03f5 \u2212greedy, a widely used exploration strategy, as an example. \u03f5\u2212greedy typically selects the action with the maximal Q value to exploit the learned experience while occasionally selecting an action evenly at random to explore unknown cases. \u03f5 \u2212greedy exploration strategy with m actions can be denoted as follow: \u03c0(a|s) = \u001a \u03f5/m + (1 \u2212\u03f5) a\u2217= arg maxa\u2208A Q(s, a), \u03f5/m a \u0338= a\u2217. (12) \u03f5 \u2208[0, 1) is an exploration factor. The agent is more likely to select the action at random when the \u03f5 is closer to 1, and the \u03f5 will be continuously reduced during the training process. 2.3 Advanced Techniques This section mainly discusses some advanced techniques in RL which focus on e\ufb03ciently using the limited samples and building sophisticated model structures for better representation and optimization. According to the di\ufb00erent improvements, they can be broadly classi\ufb01ed into two parts: data sampling and model e\ufb03ciency. 2.3.1 Data Sampling Data sampling is one of the most important concerns in training the DRL in data processing and analytics. In most applications, the sample generation process costs a great amount of time and computation resources. For example, a sample may refer to an execution run for workload and repartitioning for the database, which can take about 40 minutes[31]. Hence, to train the model with limited samples, we need to increase data utilization and reduce data correlation. Data utilization: Most DRL algorithms train the optimal policy and sample data at the same time. Instead of dropping samples after being trained, experience replay[50] accumulates the samples in a big table where samples are randomly selected during the learning phase. With this mechanism, samples will have a higher utilization rate and a lower variance, and hence, it can stabilize the training process and accelerate the training convergence. Samples after several iterations may di\ufb00er from the current policy, and hence, Growing-batch [40] can continuously refresh the table and replace these outdated samples. In addition, samples that are far away from the current policy should be paid more attention and Prioritized Experience Replay[79] uses TD error as the priority to measure the sample importance, and hence, focus more on learning the samples with high errors. In a nutshell, 9 \fwith the experience replay, DRL cannot only stable the learning phase but also e\ufb03ciently optimize the policy with fewer samples. Data correlation: Strong correlation of training data is another concern that may lead the agent to learn a sub-optimal solution instead of the globally optimal one. Apart from the experience replay, the mechanism of the distributed environments is another research direction to alleviate this problem. For example, the asynchronous advantage actor-critic (A3C) [64] and Distributed PPO (DPPO) [27] apply multi-threads to build multiple individual environments where multiple agents take actions in parallel, and the update is calculated periodically and separately which can accelerate the sampling process and reduce the data correlation. 2.3.2 Model E\ufb03ciency RL model with better e\ufb03ciency is the major driving force of the development of RL, and there are many researchers improving it from three major aspects, namely policy, reward function, and value function. Policy: The policy-related techniques focus on stably and e\ufb00ectively learning a comprehensive policy, and the advanced techniques to e\ufb03ciently learn the policy can be classi\ufb01ed into three parts in detail, which are policy exploration, policy representation, and policy optimization. a) Policy exploration: Its target is to explore as many actions as possible during the training process in case the policy will be trapped into the local optimal. For example, entropy regularisation [64] adds the entropy of the actions\u2019 probabilities into the loss item which can su\ufb03ciently explore the actions. Besides, adding noise to the action is another research direction to increase the randomness into policy exploration. The DDPG applies an Ornstein\u2013Uhlenbeck process [96] to generate temporal noise N which are directly injected into policy. Noisy-Net [22] incorporates the noise into the parameters of neural networks which is easy to implement, and it shows a better performance than the \u03f5 \u2212greedy and entropy regularisation methods. Further, Plappert et al. [75] investigate an e\ufb00ective way to combine the parameter space noise to enrich the exploratory behaviors which can bene\ufb01t both on-policy methods and o\ufb00-policy methods. b) Policy representation: The states in some RL problems are in a huge dimension which causes challenges during the training. To approximate a better policy, a branch of DRL models improve the policy representation by absorbing convolutional neural networks (CNN) into DQN to analyze the data, such as Dueling DQN [108], DRQN [26], and so on. In addition, DRQN also incorporates the LSTM structure to increase the capacity of the policy which is able to capture the temporal information, such as speed, direction. c) Policy optimization: The update of the value functions following the Equation 5 and 6 tends to overestimate the value functions and introduce a bias because they learn estimates from the estimates. Mnih et al.[66] separate the two estimation process by using two same Q-networks which can reduce the correlation of two estimation processes and hence, stabilize the course of training. However, the action with the maximum Q-value may di\ufb00er between two Q-networks which will be hard for convergence. and Double DQN (DDQN) [99] alleviate the issue by disaggregating the step of selecting the action and calculating the max Q-value. When we apply the policy-based RL methods, the learning rate of the policy plays an essential role in achieving superior performance. A higher learning rate can always maxi10 \fmize the improvement on a policy by step, but it also causes the instability of the learning phase. Hence, The Trust Region Policy Optimization (TRPO) [80] builds constraints on the old policy and new policy via KL divergence to control the change of the policy in an acceptable range. With this constraint, TRPO can iteratively optimize the policy via a surrogate objective function which can monotonically improve policies. However, the design of the KL constraint makes it hard to be trained, and Proximal Policy Optimization (PPO) [81] simpli\ufb01es the constraint through two ways: adding it into the objective function, designing a clipping function to control the update rate. Empirically, PPO methods are much simpler to implement and are able to perform at least as well as TRPO. Reward: Reward function as one of the key components in the MDP plays an essential role in the RL. In some speci\ufb01c problems, the agent has to achieve multiple goals which may have some relationships. For example, the robot can only get out through the door only if it has already found the key. To tackle this challenge, Hierarchical DQN [38] proposes two levels of hierarchical RL (HRL) models to repeatedly select a new goal and achieve the chosen goal. However, there is a limitation that the goal needs to be manually prede\ufb01ned which may be unknown or unmeasurable in some environments, such as the market and the e\ufb00ect of a drug. To overcome it, Inverse RL (IRL) [68] learns the rewards function from the given experts\u2019 demonstrations (i.e. the handcraft trajectories), but the agent in IRL can only prioritize the entire trajectories over others. It will cause a shift when the agent comes to a state that never appears before, and Generative Adversarial Imitation Learning (GAIL) [32], as an imitation learning algorithm, applies adversarial training methods to generate fake samples and is able to learn the expert\u2019s policy explicitly and directly. Value: As we have mentioned earlier, the tabular representation of the value functions has several limitations which can be alleviated via DRL. Di\ufb00erent from directly taking the state-action pair as the input to calculate the Q-function, Dueling DQN [108] estimates its value by approximating two separate parts that are the state-values and the advantage values, and hence, can distinguish whether the value is brought by the state or the action. The aforementioned advanced algorithms and techniques improve and enhance the DRL from di\ufb00erent perspectives, which makes DRL-based algorithms be a promising way to improve data processing and analytics. We observe that problems with the following characteristics may be amenable to DRL-based optimization. First, problems are incredibly complex and di\ufb03cult. The system and application involve a complicated operational environment (e.g., large-scale, high-dimensional states) and internal implementation mechanisms, which is hard to construct a white-box model accurately. DRL can process complex data and learn from experience generated from interacting, which is naturally suitable for data processing and analytics where many kinds of data exist and are processed frequently. Second, the optimization objectives can be represented and calculated easily as the reward because the RL agent improves itself towards maximizing the rewards and rewards could be computed a lot of times during training. Third, the environment can be well described as MDP. DRL has been shown to solve MDP with theoretical guarantees and empirical results. Thus, problems involving sequential decision making such as planning, scheduling, structure generation (e.g., tree, graph), and searching could be expressed as MDP and a good \ufb01t for DRL. Fourth, collecting required labels of data massively is hard. Compared to supervised learning, DRL can utilize data e\ufb03ciently to gain good performance. 11 \f3 Data System Optimizations DRL learns knowledge about the system by interacting with it and optimizes the system. In this section, we focus on several fundamental aspects with regards to system optimization in data processing and analytics including data organization, scheduling, tuning, indexing, query optimization, and cache management. We discuss how each problem is formulated in MDP by de\ufb01ning three key elements (action, state, and reward) in the system and solved by DRL. Generally, the states are de\ufb01ned by some key characteristics of the system. The actions are possible decisions (e.g., system con\ufb01guration), that a\ufb00ect the system performance and the reward is calculated based on the performance metrics (e.g. throughput, latency). Table 1 presents a summary of representative works and the estimated dimension ranges on the state and action space of each work are added as signals on the DRL training di\ufb03culty. As a comparison, OpenAI Five[8], a Dota-playing AI, observes the state as 20,000 numbers representing useful game information and about 1,000 valid actions (like ordering a hero to move to a location) for per hero. Dota is a real-time strategy game between two teams of \ufb01ve players where each player controls a character called a \u201chero\u201d. 3.1 Data Organization 3.1.1 Data Partitioning E\ufb00ective data partitioning strategy is essential to accelerate data processing and analytics by skipping irrelevant data for a given query. It is challenging as many factors need to be considered, including the workload and data characteristics, hardware pro\ufb01les, and system implementation. In data analytics systems, data is split into blocks in main memory or secondary storage, which are accessed by relevant queries. A query may fetch many blocks redundantly and, therefore, an e\ufb00ective block layout avoids reading unnecessary data and reduces the number of block accesses, thereby improving the system performance. Yang et al.[116] propose a framework called the qd-tree that partitions data into blocks using DRL over the analytical workload. The qd-tree resembles the classic k-d tree and describes the partition of multidimensional data space where each internal node splits data using a particular predicate and represents a subspace. The data in the leaf node is assigned to the same block. In the MDP, each state is a node representing the subspace of the whole data and featured as the concatenation of range and category predicates. After the agent takes an action to generate two child nodes, two new states will be produced and explored later. The available action set is the predicates parsed from workload queries. The reward is computed by the normalized number of skipped blocks over all queries. They do not execute queries and a sampling technique is used to estimate the reward e\ufb03ciently. The formulation of using DRL to learn a tree is similar to NeuroCuts[47] that learns a tree for packet classi\ufb01cation. However, the qd-tree may not support a complex workload containing userde\ufb01ned functions (UDFs) queries. Horizontal partitioning in the database chooses attributes of large tables and splits them across multiple machines to improve the performance of analytical workloads. The design relies on either the experience of database administrators (DBAs) or cost models that are often inaccurate[42] to predict the runtime for di\ufb00erent partitions. Data collection is too challenging and costly to train the accurate supervised learning model in the cloud environment. Hilprecht et al.[31] learn to partition using DRL on analytical workloads in cloud databases, on the fact that DRL is able to e\ufb03ciently navigate the partition search and 12 \frequires less training data. In the MDP, the state consists of two parts. The database part encodes whether a table is replicated, an attribute is used for partitioning, and which tables are co-partitioned. The workload part incorporates normalized frequencies of representative queries. Supported actions are: partitioning a table using an attribute, replicating a table, and changing tables co-partition. The reward is the negative of the runtime for the workload. One challenge is that the cost of database partitioning is high during training. To alleviate the problem, the agent is trained in the simulation environment and is further re\ufb01ned in the real environment by estimating the rewards using sampling. One limitation is that it may not support new queries well because only the frequency features of queries are considered. Durand et al. in [17, 18] utilize DRL to improve vertical partitioning that optimizes the physical table layout. They show that the DQN algorithm can easily work for a single workload with one table but is hard to generalize to random workloads. For UDFs analytics workloads on unstructured data, partitioning is more challenging where UDFs could express complex computations and functional dependency is unavailable in the unstructured data. Zou et al.[127] propose the Lachesis system to provide automatic partitioning for non-relational data analytics. Lachesis translates UDFs to graph-based intermediate representations (IR) and identi\ufb01es partition candidates based on the subgraph of IR as a two-terminal graph. Lachesis adopts DRL to learn to choose the optimal candidate. The state incorporates features for each partition extracted from historical work\ufb02ows: frequency, the execution interval, time of the most recent run, complexity, selectivity, key distribution, number, and size of co-partition. In addition, the state also incorporates other features such as hardware con\ufb01gurations. The action is to select one partition candidate. The reward is the throughput speedup compared to the average throughput of the historical executions of applications. To reduce the training time, the reward is derived from historical latency statistics without partitioning the data when running the applications. One limitation is that Lachesis largely depends on historical statistics to design the state and calculate the reward, which could lead to poor performance when the statistics are inadequate. 3.1.2 Data Compression Data compression is widely employed to save storage space. The e\ufb00ectiveness of a compression scheme however relies on the data types and patterns. In time-series data, the pattern can change over time and a \ufb01xed compression scheme may not work well for the entire duration. Yu et al.[120] propose a two-level compression framework, where a scheme space is constructed by extracting global features at the top level and a compression schema is selected for each point at the bottom level. The proposed AMMMO framework incorporates compression primitives and the control parameters, which de\ufb01ne the compression scheme space. Due to the fact that the enumeration is computationally infeasible, the framework proposes to adopt DRL to \ufb01nd the compression scheme. The agent takes a block that consists of 32 data points with the compressed header and data segment, timestamps, and metrics value as the state. The action is to select a scheme from compression scheme space and then the compression ratio is computed as the reward. The limitation is that the method may not work for other data types like images and videos. 3.2 Scheduling Scheduling is a critical component in data processing and analytics systems to ensure that resources are well utilized. Job scheduling in a distributed computing cluster faces many challenging factors such as workload (e.g., job dependencies, sizes, priority), data 13 \fTable 1: Representative Works using DRL for Data System Optimizations. D(X) denotes the approximate dimension of X space. Domain Work Algorithm D(State) D(Action) DRL-based Approach Open Source Data organization Analytical system data partition[116] PPO 10 100 100 1000 Exploit workload patterns and Generate the tree NO Database horizontal partition [31] DQN 100 10 Navigate the partition search e\ufb03ciently NO UDF-centric workload data partition [127] A3C 10 1-10 Exploit the features of partition and search YES Time series data compression [120] PG 100 10 Search parameters interactively NO Scheduling Distributed job processing [58] PG 100 10 Exploit the job dependencies and learn schedule decision YES Distributed stream data [45] DDPG 100 10-100 Learn schedule decision NO Tuning Database con\ufb01guration [123] [44] DDPG 100 10 Search con\ufb01guration parameters interactively YES Index Index Selection [84] CEM 100 10 Search the index interactively NO R-tree construction [24] DQN 10-100 10 Learn to generate the tree NO Query Optimization Join order selection [61, 37, 119, 29] PG, DQN, ... 10-100 1-10 Learn to decide the join order Only [29] Cache Management View Materialization [121] DQN 100 10 Model the problem as IIP and solve NO locality, and hardware characteristics. Existing algorithms using general heuristics such as shortest-job-\ufb01rst do not utilize these factors well and fail to yield top performance. To this end, Mao et al.[58] propose Decima to learn to schedule jobs with dependent stages using DRL for data processing clusters and improve the job completion time. In the data processing systems such as Hive[93], Pig[70], Spark-SQL[1], jobs could have up to hundreds of stages and many stages run in parallel, which are represented as directed acyclic graphs (DAGs) where the nodes are the execution stages and each edge represents the dependency. To handle parallelism and dependencies in job DAGs, Decima \ufb01rst applies graph neural network (GNN) to extract features as the state instead of manually designing them while achieving scalability. Three types of feature embeddings are generated. Node embedding captures information about the node and its children including the number of remaining tasks, busy and available executors, duration, and locality of executors. Job embedding aggregates all node embeddings in the job and cluster embedding combines job embeddings. To balance possible large action space and long action sequences, The action determines the job stage to be scheduled next and the parallelism limit of executors. The reward is based on the average job completion time. To train e\ufb00ectively in a job streaming environment, Decima gradually increases the length of training jobs to conduct curriculum learning[7]. The variance reduction technique[59] is applied to handle stochastic job arrivals for robustness. However, we note that Decima is non-preemptive and does not re-schedule for higher priority jobs. 14 \fIn distributed stream data processing, streams of continuous data are processed at scale in a real-time manner. The scheduling algorithm assigns workers to process data where each worker uses many threads to process data tuples and aims to minimize average data tuple processing time. Li et al.[45] design a scheduling algorithm using DRL for distributed stream data processing, which learns to assign tuples to work threads. The state consists of the scheduling plan (e.g., the current assignment of workers) and the workload information (e.g., tuple arrival rate). The action is to assign threads to machines. The reward is the negative tuple processing time on average. The work shows that DQN does not work well because the action space is large and applies DDPG to train the actor-critic based agent instead. To \ufb01nd a good action, the proposed method looks for k nearest neighbors of the action that the actor network outputs and selects the neighbor with the highest value that the critic network outputs. The algorithm is implemented on Apache Storm and evaluated with representative applications: log stream processing, continuous queries, and word count. Many works have been recently proposed to improve scheduling using DRL[122, 35]. Query scheduling determines the execution order of queries, which has a great in\ufb02uence on query performance and resource utilization in the database system. SmartQueue[122] improves query scheduling by leveraging overlapping data access among queries and learns to improve cache hits using DRL. In addition, Tim et al.[35] design a scheduling system in SageDB using RL techniques. Other works using RL for scheduling include Bayesian RL for scheduling in heterogeneous clusters[3], operation scheduling in devices[23], application container scheduling in clusters[102], etc. 3.3 Tuning Tuning the con\ufb01guration of data processing and analytic systems plays a key role to improve system performance. The task is challenging because up to hundreds of parameters and complex relations between them could exist. Furthermore, other factors such as hardware and workload also impact the performance. Existing works often employ search-based or supervised learning methods. The former takes much time to get an acceptable con\ufb01guration and the latter such as OtterTune[98] needs large high-quality data that is non-trivial to obtain in practice. Zhang et al.[123] design a cloud database tuning system CDBTune using DRL to \ufb01nd the best parameter in high-dimensional con\ufb01guration space. The CDBTune formulates MDP as follows. The state is represented by the internal metrics (e.g., bu\ufb00er size, pages read). The action is to increase or decrease the knob values. The reward is the performance di\ufb00erence between two states, which is calculated using throughput and latency. CDBTune takes several hours on o\ufb04ine training in simulation and online training in the real environment. Compared to OtterTune, CDBTune eases the burden of collecting large training data sets. In the experiments, CDBTune is shown to outperform DBA experts and OtterTune and improve tuning e\ufb03ciency under 6 di\ufb00erent workloads on four databases. One limitation of the approach is that the workload information is ignored and thus it may not perform well when the query workload is changed. To address the issue, Li et al.[44] propose QTune that considers query information to tune the database using DRL. First, Qtune extracts features from SQL query including types (e.g., insert, delete), tables, and operation (e.g., scan, hash join) costs estimated by the database engine. The columns attributes and operations like selection conditions in the query are ignored. Subsequently, Qtune trains a DNN model to predict the di\ufb00erence of statistics (e.g., updated tuples, the number of committed transactions) in the state after executing the queries in the workload and updates the state using it. The action 15 \fand reward design are similar to CDBTune. Additionally, QTune supports three levels of tuning granularity for balancing throughput and latency. For query-level, QTune inputs query vector and tries to \ufb01nd good knobs for each query. For workload-level, vectors for all queries are merged and used. For cluster-level, QTune employs a clustering method based on deep learning to classify queries and merge queries into clusters. One drawback of QTune is that the query featurization could lose key information such as query attributes (i.e., columns) and hurt the performance especially when the cost estimation is inaccurate. The prediction model for state changes is trained alone and needs accurate training data. An end-to-end training framework is therefore essential and a good direction to undertake. 3.4 Indexing 3.4.1 Database Index Selection Database index selection considers which attributes to create an index to maximize query performance. Sharma et al.[84] show how DRL can be used to recommend an index based on a given workload. The state encodes selectivity values for workload queries and columns in the database schema and current column indexes. The action is to create an index on a column. The reward is the improvement compared to the baseline without indexes. The experiments show that the approach can perform as well or better as having indexes on all columns. Sadri et al.[78] utilize DRL to select the index for a cluster database where both query processing and load balancing are considered. Welborn et al.[110] optimize the action space design by introducing task-speci\ufb01c knowledge for index selection tasks in the database. However, these works only consider the situation where single-column indexes are built. Lan et al.[39] propose both single-attribute and multi-attribute indexes selection using DRL. Five rules are proposed to reduce the action and state space, which help the agent learn e\ufb00ective strategy easier. The method uses what-if caller[9] to get the cost of queries under speci\ufb01c index con\ufb01gurations without building indexes physically. These works conduct basic experiments with small and simple datasets. Extensive and large-scale experiments using real datasets are therefore needed to benchmark these methods to ensure that they can scale well. 3.4.2 Index Structure Construction The learned index is proposed recently as an alternative index to replace the B+-Tree and bloom \ufb01lter by viewing indexes as models and using deep learning models to act as indexes[36]. DRL can enhance the traditional indexes instead of replacing them. Hierarchical structures such as the B+-tree and R-tree are important indexing mechanisms to locate data of interest e\ufb03ciently without scanning a large portion of the database. Compared to the single dimensional counterpart, the R-tree is more complex to optimize due to bounding box e\ufb03ciency and multi-path traversals. Earlier conventional approaches use heuristics to determine these two operations (i.e. choosing the insertion subtree and splitting an over\ufb02owing node) during the construction of the R-tree[71]. Gu et al.[24] propose to use DRL to replace heuristics to construct the R-tree and propose the RLR-tree. The approach models two operations ChooseSubtree and Split as two MDPs respectively and combines them to generate an R-Tree. For ChooseSubtree, the state is represented as the concatenation of the four features (i.e., area, perimeter, overlap, occupancy rate) of each selected child node. More features are evaluated but do not improve the performance in the reported experiments. The action is to select a node to insert from top-k child nodes in terms of the increase of area. The reward is the performance improvement from the 16 \fRLR-tree. For Split MDP, the state is the areas and perimeters of the two nodes created by all top-k splits in the ascending order of total area. The action is to choose one split rule from k rules and the reward is similar to that of ChooseSubtree. The two agents are trained alternately. As expected, the optimizations render the RLR-tree improved performance in range and KNN queries. Graphs can be used as e\ufb00ective indexes to accelerate nearest neighbors search[55, 15]. Existing graph construction methods generally propose di\ufb00erent rules to generate graphs, which cannot provide adaptivity for di\ufb00erent workloads[104]. Baranchuk et al.[5] employ DRL to optimize the graph for nearest neighbors search. The approach learns the probabilities of edges in the graph and tries to maximize the search e\ufb03ciency. It considers the initial graph and the search algorithm as the state. The action is to keep an edge or not. The reward is the performance for search. It chooses the TRPO[80] algorithm to train. The reported experimental results show that the agent can re\ufb01ne state-of-the-art graphs and achieve better performance. However, this approach does not learn to explore and add new edges to the initial graph that may a\ufb00ect the performance. Searching and constructing a new index structure is another line of interesting research [33]. Inspired by Neural Architecture Search (NAS)[126], Wu et al.[112] propose an RNN-based neural index search (NIS) framework that employs DRL to search the index structures and parameters given the workload. NIS can generate tree-like index structures layer by layer via formalizing abstract ordered blocks and unordered blocks, which can provide a well-designed search space. The keys in the ordered block are sorted in ascending order, and the skip list or B+-Tree can be used. The keys in the unordered block are partitioned using customized functions and the hash bucket can be used. Overall, the whole learning process is similar to that of NAS. 3.5 Query Optimization Query optimization aims to \ufb01nd the most e\ufb03cient way to execute queries in database management systems. There are many di\ufb00erent plans to access the query data that can have a large processing time variance from seconds to hours. The performance of a query plan is determined mostly by the table join orders. Traditionally, query optimizers use certain heuristics combined with dynamic programming to enumerate possible e\ufb03cient execution plans and evaluate them using cost models that could produce large errors[42]. Marcus et al.[61] propose Rejoin that applies DRL to learn to select better join orders utilizing past experience. The state encodes join tree structure and join predicates. The action is to combine two subtrees, where each subtree represents an input relation to join. The reward is assigned based on the cost model in the optimizer. The experiments show that ReJOIN can match or outperform the optimizer in PostgreSQL. Compared to ReJoin, DQ[37] presents an extensible featurization scheme for state representation and improves the training e\ufb03ciency using the DQN[65] algorithm. Heitz et al.[29] compare di\ufb00erent RL algorithms including DQN[65], DDQN[49], and PPO[81] for join order optimization and use a symmetric matrix to represent the state instead of vector. Yu et al.[119] introduce a graph neural network (GNN) with DRL for join order selection that replaces \ufb01xed-length hand-tuned vector in Rejoin[61] and DQ[37] with learned scalable GNN representation and better captures and distinguishes the join tree structure information. These works mainly di\ufb00er in encoding what information and how to encode them. Instead of learning from past query executions, Trummer et al.[94] propose SkinnerDB to learn from the current query execution status to optimize the remaining execution of a 17 \fTable 2: Methods of query optimization. Method Techniques Training Workload Adaptivity Rejoin[61], DQ[37] learn from execution experience High Low SkinnerDB [94] learn from current execution status Medium Medium Bao[60] learn to choose existing optimizers Low High query using RL. Speci\ufb01cally, SkinnerDB breaks the query execution into many small time intervals (e.g., tens to thousands of slices per second) and processes the query adaptively. At the beginning of each time interval, the RL agent chooses the join order and measures the execution progress. SkinnerDB adopts a similar adaptive query processing strategy in Eddies[95] and uses the UCT algorithm[34], which provides formal guarantees that the di\ufb00erence is bounded between the rewards obtained by the agent and those by optimal choices. The reward is calculated by the progress for the current interval. A tailored execution engine is designed to fully exploit the learning strategy with tuple representations and specialized multi-way join algorithms. SkinnerDB o\ufb00ers several advantages. First, it is inherently robust to query distribution changes because its execution only depends on the current query. Second, it relies on less assumption and information (e.g., cardinality models) than traditional optimizers and thus is more suitable for the complicated environment where cardinality is hard to estimate. Third, it predicts the optimal join order based on real performance. However, it may introduce overhead caused by join order switching. Learning-based methods that have been proposed to replace traditional query optimizers often incur a great deal of training overhead because they have to learn from scratch. To mitigate the problem, Bao [60] (the Bandit optimizer)) is designed to take advantage of the existing query optimizers. Speci\ufb01cally, Bao learns to choose the best plan from the query plan candidates provided by available optimizers by passing di\ufb00erent \ufb02ags or hints to them. Bao transforms query plan trees into vectors and adopts a tree convolutional neural network to identify patterns in the tree. Then it formulates the choosing task as a contextual multi-armed bandit problem and uses Thompson sampling[92] to solve it. Bao is a hybrid solution for query optimization. It achieves good training time and is robust to changes in workload [60]. 3.6 Cache Management 3.6.1 View Materialization View materialization is the process of deciding which view, i.e., results of query or subquery, to cache. In database systems, a view is represented as a table and other queries could be accelerated by reading this table instead of accessing the original tables. There is an overhead of materializing and maintaining the view when the original table is updated. Existing methods are based on heuristics, which either rely on simple Least-Recently-Used rule or cost-model based approaches[74]. The performance of these approaches is limited because feedback from the historical performance of view materialization is not incorporated. Liang et al.[48] implement Deep Q-Materialization (DQM) system that leverages DRL to improve the view materialization process in the OLAP system. First, DQM analyzes SQL queries to \ufb01nd candidate views for the current query. Second, it trains a DRL agent to select from the set of candidates. Third, it uses an eviction policy to delete the 18 \fmaterialized views. In the MDP, the state encodes view state and workload information. The action is to create the view or do nothing. The reward is calculated by the query time improvement minus amortized creation cost. Additionally, the eviction policy is based on credit and it evicts the materialized view with the lowest score. Yuan et al.[121] present a di\ufb00erent way that use DRL to automate view generation and select the most bene\ufb01cial subqueries to materialize. First, the approach uses a DNN to estimate the bene\ufb01ts of a materialized view where features from tables, queries, and view plans are extracted. Then the approach models selection as an Integer Linear Programming (IIP) problem and introduce an iterative optimization method to \ufb01gure it out. However, the method cannot guarantee convergence. To address the issue, the problem is formulated as the MDP. The state encodes the subqueries that are selected to materialize and status if queries use these materialized views. The action is to choose the subquery to materialize or not. The reward is the di\ufb00erence between bene\ufb01t changes of two states. Both cost estimation and view selection models are trained o\ufb04ine using the actual cost of queries and bene\ufb01ts. Then the cost estimation model is used for the online recommendation for view materialization. Performance study shows its good performance; However, it lacks a comparison with DQM. 3.6.2 Storage Cache management impacts the performance of computer systems with hierarchical hardware structures directly. Generally, a caching policy considers which objects to cache, to evict when the cache is full to maximize the object hit rate in the cache. In many systems, the optimal caching policy depends on workload characteristics. Phoebe[111] is the RL-based framework for cache management for storage models. The state encodes the information from a preceding \ufb01xed-length sequence of accesses where for each access, nine features are extracted including data block address, data block address delta, frequency, reuse distance, penultimate reuse distance, average reuse distance, frequency in the sliding window, the number of cache misses, and a priority value. The action is to set a priority value ranging within [\u22121, 1] to the data. The reward is computed from if the cache is hit or missed and values are 1 and -1 respectively. It applies the DDPG algorithm to train the agent. Periodical training is employed to amortize training costs in online training. In network systems, one issue is that the reward delay is very long in systems with a large cache, i.e., CDN cache can host up to millions of objects. Wang et al.[100] propose a subsampling technique by hashing the objects to mitigate the issue when applying RL on caching systems. 4 Data Analytics Applications In this section, we shall discuss DRL applications from the perspective of data processing and data analytics. These two categories of DRL applications form indispensable parts of a pipeline, in which data processing provides a better basis for data analytics. In addition, these two categories share some overlapping topics, making these topics mutually motivating and stimulating. We have summarized the technical comparisons of di\ufb00erent applications in Table 3. We shall \ufb01rst discuss DRL applications in data preparation and then in data analytics. 19 \fTable 3: Representative works for RL applications. D(X) denotes the approximate dimension of X space. Domain Work Algorithm D(State) D(Action) DRL-based Approach Data processing Entity matching[11, 20] PG 100 1000 100 1000 Select target entity from the candidate entities application Database interaction with natural language [125, 14] PG 100 1000 100 1000 Learn to generate the query Feature engineering [52] DQN 100 1-10 Select features and model feature correlations in states Exploratory data analysis [4] A3C 10-100 100000 Learn to query a dataset for key characteristics Abnormal detection [69] IRL 1-10 1-10 Learn the reward function for normal sequences AutoML pipeline generation [28] DQN 10 100 Learn to select modules of a pipeline Healthcare Treatment recommendation [103] DDPG 10 100-1000 Select treatment from candidate treatments Diagnostic inference [51] DQN 100-1000 1-10 Learn diagnostic decision Hospital resource allocation [19] DDPG 100 100010000 Learn resource scheduling Fintech Portfolio optimization [12] QLearning 100 100 Select the portfolio weights for stocks Trading [115, 114] IRL 1-10 10 Learn the reward function of trading behaviors Fraud detection [114] IRL 100 10-100 Learn the reward function of trading behaviors EOnline advertising [124] DQN 1-10 1-10 Learn to schedule the advertisements Commerce Online recommendation [10] DQN 100 10000 Learn to schedule recommendations Search results aggregation [91] DQN 10-100 10-100 Learn to schedule search results Others User pro\ufb01ling [105] DQN 100-1000 100010000 Select users\u2019 next activities by modeling spatial semantics Spammer detection [16] PG 100 100 Search for the detector by interacting with spammers Transportation [83] PG 100010000 1000 Learn to schedule transportation 20 \f4.1 Data Preparation 4.1.1 Entity Matching Entity matching is a data cleaning task that aligns di\ufb00erent mentions of the same entity in the context. Clark et al. [11] identify the issue that the heuristic loss function cannot e\ufb00ectively optimize the evaluation metric B3, and propose using reinforcement learning to directly optimize the metric. The problem is formulated as a sequential decision problem where each action is performed on one mention of a document. The action maps the mention to an entity in the database at each step by a mention ranking model. Then the reward is calculated using the evaluation metric B3. This work originally proposes scaling each action\u2019s weight by measuring its impact on the \ufb01nal reward since each action is independent. However, this work does not consider the global relations between entities. Fang et al. [20] propose a reinforcement learning framework based on the fact that an easier entity will create a better context for the subsequent entity matching. Speci\ufb01cally, both local and global representations of entity mentions are modeled and a learned policy network is devised to choose from the next action (i.e., which entity to recognize). However, the selection of the easier entity to learn the context could be less powerful than context modeling with more recent techniques in NLP such as the transformer. 4.1.2 Database Interaction With Natural Language To facilitate query formulation for relational databases, there have been e\ufb00orts in generating SQL queries from various other means that do not require knowledge of SQL and schema. Zhong et al. [125] propose to generate SQL from a natural language using Reinforcement Learning. For queries formed by a natural language, the model Seq2SQL will learn a policy transforming the queries into SQL queries. The transformed queries will then be executed in the database system to get results. The results will be compared with the ground truth to generate RL rewards. Earlier work [14] using generic autoencoder model for semantic parsing with Softmax as the \ufb01nal layer may generate unnecessarily large output spaces for SQL query generation tasks. Thus the structure of SQL is used to prune the output space of query generating and policy-based reinforcement learning to optimize the part which cannot be optimized by cross-entropy. However, RL is observed to have limited performance enhancement by [113] due to unnecessary modeling of query serialization. E\ufb03ciently querying a database of documents is a promising data processing application. Karthik et al. [67] propose collecting evidence from external sources of documents to boost extraction accuracy to original sources where data might be scarce. The problem is formulated as an MDP problem, where each step the agent needs to decide if current extracted articles are accepted and stop querying, or these articles are rejected and more relevant articles are queried. Both data reconciliation (from original sources) and data retrieval (from external sources) are represented as states. Extraction accuracy and penalties for extra retrieval actions are re\ufb02ected in the reward function. 4.1.3 Feature Engineering Feature engineering can be formulated as a single-agent reinforcement learning problem to search for an optimal subset of features in a large space: the agent selects one feature at each action step. The state is the current feature subspace. A reward is assigned to the agent based on the predictive performance of the current features subset. Liu et al. [52] 21 \fpropose a method to reformulate feature engineering as a multi-agent reinforcement learning problem. The multi-agent RL formulation reduces the large action space of a single agent since now each of the agents has a smaller action space for one feature selection. However, this formulation also brings challenges: interactions between agents, representation of the environment, and selection of samples. Three technical methods in [52] have been proposed to tackle them respectively: adding inter-feature information to reward formulation, using meta statistics, and deep learning methods to learn the representation of the environment, and Gaussian mixture to independently determine samples. However, although this formulation reduces the action space, the trade-o\ufb00is using more computing resources to support more agents\u2019 learning. Also, the method is di\ufb03cult to scale to a large feature space. 4.1.4 Exploratory Data Analysis Exploratory data analysis (EDA) is useful for users to understand the characteristics of a new dataset. In [4], the problem is formulated as a MDP. The action space is the combination of a \ufb01nite set of operators and their corresponding parameters to query a dataset. The result of a query shows the characteristics of the dataset. The characteristics are modeled as the state, which is represented by descriptive statistics and recent operators. The reward signal measures the interestingness, diversity, and coherency of the characteristics by an episode of EDA operations. DRL is applied to the non-di\ufb00erential signals and discrete states in MDP. However, challenges arise when applying deep reinforcement learning given a large number of possible actions as parameterized operations (i.e., for each type of operation, the corresponding possible action is the Cartesian product of all parameters\u2019 possible values). In [4], a two-fold layer architecture is proposed to replace a global softmax layer into two local layers, which e\ufb00ectively reduces the intractable large numbers of actions. However, the global interactions of operations and attributes are not considered. 4.1.5 Abnormal Detection Abnormal detection is important for high-stake applications such as healthcare (e.g., predicting patients\u2019 status) and \ufb01ntech (e.g., \ufb01nancial crime). Based on the assumptions, there are two approaches to this problem. One approach models the dynamics in the unlabeled datasets as a sequential decision process where the agent performs an action on each observation. Oh et al. [69] propose to use IRL to learn a reward function and a Bayesian network to estimate a con\ufb01dence score for a potential abnormal observation. To achieve this, the prior distribution of the reward function is assumed. Then a reward function is sampled from the distribution to determine the sample generating policy, which generates sample background trajectories. As explained by the reward part of Section 2.3.2, experts\u2019 trajectories are observed. With these experts\u2019 trajectories and sample background trajectories, the parameters of the reward function are updated and thus the policy is improved. The sequence of actions is the input into the neural network. This network is trained to learn the normal pattern of a targeted agent and to predict if the next observation is abnormal or not. However, this approach relies too much on mining unlabeled datasets and ignores the labeled dataset. To address this issue, another approach also uses DRL but focus on the Exploit-Explore trade-o\ufb00on both unlabeled and labeled dataset. Pang et al. [73] propose a DRL model with a sampling function to select data instances from both the unlabeled and labeled dataset. This sampling function helps the DRL model to exploit the scarce but useful labeled anomaly data instances and to explore the large unlabeled dataset for novel anomaly data instances. Thus, more anomaly data instances are selected 22 \fto train the DRL model with better model capacity. 4.1.6 AutoML Pipeline Generation Pipeline generation includes generating all data processing and analytics steps or modules to perform ML tasks. He\ufb00etz et al. [28] propose a grid-world to represent all possible families of each step of a data pipeline as cells and connect all possible cells as a graph. Subsequently, a hierarchical method is used to reduce the space of all actions and represent all actions by layers of clusters. Finally, the state representations are inputs to the value sub-network in a DQN network, and action representations are inputs to evaluate the advantage-to-average sub-network. 4.2 Healthcare Healthcare analytics has gained increasing attention in tandem with the advancement of healthcare treatment and availability of medical data and computational capacity [41]. Naturally, a great amount of e\ufb00ort has been spent on applying DRL to healthcare. As before, implementing DRL-based models in healthcare requires the understanding of the application context and de\ufb01ning the key elements of MDP. However, di\ufb00erences occur in the approaches to learning better decisions: learning the motivation of expert decisions by IRL, learning better decisions without an expert by interacting with an environment or interacting with an environment with expert decisions as supervising signals. 4.2.1 Treatment Recommendation Treatment recommendation systems are designed to assist doctors to make better decisions based on electronic health records. However, the doctors\u2019 prescriptions are not ground truth but valuable suggestions for high stake medical cases. The ground truth is the delayed condition of the patients. Thus model predictions must not deviate from the doctors\u2019 judgments too much, and not use those judgments as true labels. To tackle this challenge, Wang et al. [103] propose an architecture to combine supervised learning and reinforcement learning. This model reduces the inconsistency between indicator signals learned from doctor\u2019s prescriptions via supervised learning and evaluation signals learned from the long-term outcome of patients via reinforcement learning. In the formulated MDP, the domain expert makes a decision based on an unknown policy. The goal is to learn a policy that simultaneously reduces the di\ufb00erence between the chosen action of the agent and the expert\u2019s decision and to maximize the weighted sum of discounted rewards. 4.2.2 Diagnostic Inference Using DRL to perform diagnosis can provide a second opinion in high-intensity diagnosis from historical medical records to reduce diagnostic errors. Ling et al. [51] propose modeling the integration of external evidence to capture diagnostic concept as a MDP. The objective is to \ufb01nd the optimal policy function. The inputs are case narratives and the outputs are improved concepts and inferred diagnoses. The states are a set of measures over the similarity of current concepts and externally extracted concepts. The actions are whether to accept (part of) the extracted concepts from external evidence. The environments are the top extracted case narratives from Wikipedia as the document pool for concepts extraction and a knowledge base for evaluating the intermediate results for current best concepts. The rewards are evaluated based on an external knowledge base mapping from the concepts to the diagnoses. The whole process is modeled by DQN. At 23 \feach step, narrative cases and evidence are extracted, which provide the initial concepts and external concepts. The state representing the agent\u2019s con\ufb01dence in the learned concept is duly calculated. Then the state is sent to the DQN agent to estimate the reward to model the long-run accuracy of the learned concept by the agent. Iteratively, the model converges with better concepts and diagnoses. 4.2.3 Hospital Resource Allocation Allocating limited hospital resources is the key to providing timely treatment for patients. In [19], the problem is formulated as a classi\ufb01cation problem where the patients\u2019 features are given and the target is to predict the location of admissions. The RL framework uses a student network to solve the classi\ufb01cation problem. The weights of the student network are used as states, which are fed into a teacher network to generate actions to select which batch of data to train the student network. The accuracy of the classi\ufb01cation is used as the reward. This method provides a view on the resource allocation problem from a curriculum learning perspective. However, the temporal information of the data samples is not considered but it could a\ufb00ect resource allocation since some hours during a day could have fewer patients than the others. 4.3 Fintech Reinforcement learning has wide applications in the \ufb01nance domain. Firstly, reinforcement learning has brought new perspectives to let the \ufb01nance research community revisit many classic \ufb01nancial research topics. For example, traditional \ufb01nancial research topics such as option pricing that are typically solved by the classic Black\u2013Scholes model can be steered through with a data-driven insight by reinforcement learning [25]. Secondly, portfolio optimization, typically formulated as a stochastic optimal control problem, can be addressed by reinforcement learning. Finally, the agents are \ufb01nancial market participants with different intentions. Reward functions can be learned to model these intentions, and hence, make better decisions as illustrated in Figure 3. We refer readers with further interest in \ufb01nance to [62]. 4.3.1 Dynamic Portfolio Optimization The portfolio optimization problem is challenging because of the high scale of the dimensionality and the high noise-to-signal ratio nature of stock price data. The latter problem of noisy observation can cause uncertainty in a learned policy. Therefore, [12] proposes a novel model structure based on the Q-learning to handle noisy data and to scale to high dimensionality. The quadratic form of reward function is shown to have a semi-analytic solution that is computationally e\ufb03cient. In the problem formulation, the agent\u2019s actions are represented as the changes in the assets at each time step. The states are the concatenation of market signals and the agent\u2019s holding assets. This method enhances Q-learning by introducing an entropy term measuring the noise in the data. This term acts as a regularization term forcing the learned policy to be close to a reference policy that is modeled by a Gaussian distribution. 4.3.2 Algorithm Trading Strategy Identi\ufb01cation Identi\ufb01cation of algorithm trading strategies from historical trades is important in fraud detection and maintaining a healthy \ufb01nancial environment. [114] proposes using IRL to learn the reward function behind the trading behaviors. The problem is formulated as 24 \fFigure 3: DRL in \ufb01ntech applications. an Inverse Markov Decision Process (IMDP). The states are the di\ufb00erences between the volumes of bid orders and ask orders, which are discretized into three intervals based on the values of the volumes. The actions are the limit and market order discretized into 10 intervals each by their values. The prior distribution of the reward function is a Gaussian Process parameterized by \u03b8. Given \u03b8, the approximation of the posterior distribution of reward is performed by maximum a posteriori (MAP). This step would give a MAP estimated value of the reward. \u03b8 is optimized by a log-likelihood function on the posterior of observations. The optimization process can be proved to be convex which guarantees the global minimum. The learned features are then used to identify and classify trading strategies in the \ufb01nancial markets. 4.3.3 Sentiment-based Trading One of the main predictors in stock trading is sentiment, which drives the demand of bid orders and asks orders. Sentiment scores are often represented by unstructured text data such as news or twitters. [115] proposes treating the sentiment as the aggregated action of all the market participants, which has the advantage of simplifying the modeling of the numerous market participants. Speci\ufb01cally, the sentiment scores are categorized into three intervals: high, medium, and low as the action spaces. Compared to previous works, the proposed method can model the dependency between the sentiment and the market state by the policy function. This method is based on Gaussian Inverse Reinforcement Learning [43] similar to [114] as discussed at the beginning of Section 4.3, which is e\ufb00ective at dealing with uncertainty in the stock environment. This method provides a method for modeling market sentiments. However, as IRL faces the challenge of non-uniqueness of reward [13] of one agent\u2019s actions, the method does not address how aggregated actions of multiple market participants can infer a unique reward function. 25 \f4.4 E-Commerce 4.4.1 Online Advertising With the increasing digitalization of businesses, sales and competition for market shares have moved online in tandem. As a result, online advertising has been increasing in its presence and importance and exploiting RL in various aspects. One of the topics in online advertising, bidding optimization, can be formulated as a sequential decision problem: the advertiser is required to have strategic proposals with bidding keywords sequentially to maximize the overall pro\ufb01t. In [124], the issue of using static transitional probability to model dynamic environments is identi\ufb01ed and a new DRL model is proposed to exploit the pattern discovered from dynamic environments. Including but not limited to advertising, Feng et al. [21] propose to consider the whole picture of multiple ranking tasks that occurred in the sequence of user\u2019s queries. A new multi-agent reinforcement learning model is proposed to enable multiple agents to partially observe inputs and choose actions through their own actor networks. The agents communicate through a centralized critic model to optimize a shared objective. This allows di\ufb00erent ranking algorithms to reconcile with each other when taking their own actions and consider the contextual information. 4.4.2 Online Recommendation The problem of an unstabilized reward function arises because of the dynamic environment in the online recommendation. For example, user preference is modeled as the reward in DRL and it changes unexpectedly when a special discount happens for some products. In [10], a random strati\ufb01ed sampling method is proposed to calculate the optimal way of stratifying by allocating more samples to the strata with more weighted variance. Then the replay sampling is improved to consider key attributes of customers (e.g., gender, age, etc.), which are less volatile in the dynamic environment. This allows the modeling of reward function based on sampling from a pool with a longer horizon, thus reducing the bias in the estimation of the reward function. Lastly, the dynamic environment poses a challenge in setting an optimal policy used in regretting. A new method in [10] is proposed to train an o\ufb04ine model to calculate a real-time reward for a subset of customers to approximate a reference policy, that is used as an o\ufb00set in the reward recalibration to stabilize the performance of the DRL algorithm. 4.4.3 Search Results Aggregation Aggregating useful search results in online shopping search is important to improve the shopping experience. However, the challenge of aggregating heterogeneous data sources is often encountered. The heterogeneous data sources in online shopping are di\ufb00erent product categories such as a shoe brand group or a particular topic group, each of which is a ranking system. A new model in [91] is proposed to decompose the task into two sub-tasks. The \ufb01rst one is to select a data source for the current page of search results based on historical users\u2019 clicks on previous pages. Learning to select the correct data source for each page is a sequential decision-making problem. The second sub-task is to \ufb01ll the sequence of a page by selecting the best source from the candidate sources. However, the items from di\ufb00erent sources cannot be directly compared because of their heterogeneous nature. The problem is solved by formulating the sub-task as an RL task to let an agent \ufb01ll up the sequence. However, one limitation of this method is that lacking full annotations of item relevance scores may constrain the model\u2019s performance on various scenarios [91]. 26 \f4.5 Other Applications DRL has been applied to various other applications. These DRL methods are often used with a knowledge graph, confounders, or game theory to model application-speci\ufb01c dynamics. These methods are not only well motivated from their respective applications but also general enough to be applied in other applications. However, these methods often fail to be evaluated by experiments in other applications. The problem of mobile user pro\ufb01ling aims to identify user pro\ufb01les to provide personalized services. In [105], the action is the selection of a place of visit. The environment is comprised of all users and a knowledge graph learning the semantic connections between the spatial entities. The knowledge graph is updated once a user\u2019s new activity is performed and then a\ufb00ects the agent\u2019s prediction. The state is the embedding of a user and the knowledge graph for the current time step. The reward is determined by several metrics measuring the similarity between the predicted spatial entities and the ground truth. This method considers the spatial semantics of entities but does not consider how the change of a user\u2019s key attributes (e.g., career) will a\ufb00ect activity prediction and policy learning, which could cause instability in policy updating. In the transportation system, drivers often get recommendations and provide feedback in return to improve the service. However, the recommendation often fails when drivers make decisions in a complex environment. To address this issue, in [83] a new method is proposed to model hidden causal factors, called confounders, in a complex environment. Speci\ufb01cally, the framework in [32] is extended to include the confounders. First, all three elements (i.e., policy agent, environment, confounder) are treated as agents. The e\ufb00ect of a confounder is modeled as the policy of the hidden agent, which takes the observation and action of the policy agent as inputs and performs an action. The environment in turn takes the action based on inputs of the hidden agent\u2019s action and the policy agent\u2019s action and observation. The problem of spammer detection aims to detect spam generating strategies. The challenge is that the detectors only detect easier spams while missing spams with strategies. In [16], the problem is formulated as two agents counteracting each other. One agent is the spammer, whose policy is to maintain a distribution of spam strategies and the action is to sample from the distribution. Another agent is the detector, whose state is the detection results after a spam attack and the action is to identify the spam. The rewards of two agents are measured by winning or losing revenue manipulation, respectively. The limitation of this method is that there is no guarantee for equilibrium. 5 Open Challenges and Future Directions RL approaches provide strong alternatives to traditional heuristics or supervised learningbased algorithms. However, many challenges remain to be addressed to make RL a practical solution in the context of data processing and analytics. We also foresee many important future research directions to be developed. 5.1 Open Challenges For System Optimization 5.1.1 MDP Formulation and Lack of Justi\ufb01cation The design of MDP impacts the performance and e\ufb03ciency of the RL algorithm greatly. The state should satisfy Markov property that its representation contains enough relevant 27 \finformation for the RL agent to make the optimal decision. It should summarize the environment compactly because a complicated state design will cause more training and inference costs. The action space should be designed carefully to balance learning performance and computational complexity. The reward de\ufb01nition directly a\ufb00ects the optimization direction and the system performance. Additionally, the process of reward calculation can involve costly data collection and computation in the data systems optimization. Currently, many works rely on experimental exploration and experience to formulate MDP while some works exploit domain knowledge to improve the MDP formulation by injecting task-speci\ufb01c knowledge into action space[110]. Generally, MDP can in\ufb02uence computational complexity, data required, and algorithm performance. Unfortunately, many works lack ablation studies of their MDP formulations and do not justify the design in a convincing manner. Therefore, automation of MDP formulation remains an open problem. 5.1.2 RL Algorithm and Technique Selection RL algorithms and techniques have di\ufb00erent tradeo\ufb00s and assumptions. Value-based DRL algorithms like DQN are not stable and guaranteed convergence. Policy-based DRL algorithms like TRPO and PPO are often not e\ufb03cient. Model-based DRL algorithms do not guarantee that a better model can result in a better policy. Value-based methods assume full observability while policy-based ones assume episodic learning. O\ufb00-policy algorithms are usually more e\ufb03cient than on-policy algorithms in terms of sample e\ufb03ciency. One example is that DQ[37] uses o\ufb00-policy deep Q-learning to increase data e\ufb03ciency and reduce the number of training queries needed. Training e\ufb03ciency can be a big concern for DRL-based system optimization, especially when the workload of the system could change dramatically and the model needs to be retrained frequently. Generally, RL algorithms and techniques selection a\ufb00ect the training e\ufb03ciency and e\ufb00ectiveness greatly. 5.1.3 Integration with Existing Systems Integrating RL-based methods into the real system more naturally and seamlessly faces many challenges. The RL agent has to be evolved when the system environment changes (e.g., workload) and the performance is degraded. We need to design new model management mechanisms to monitor, maintain, and upgrade the models. Furthermore, we \ufb01nd that the RL-based solutions can be lightweight or intrusive. The lightweight approach in which the RL agent is not designed as a component of the system, e.g. using RL to generate the qd-tree[116], is easier to integrate into the system because it does not change the architecture of the system dramatically. In contrast, the intrusive approach such as using RL models for join order optimization[61] is deeply embedded in the system and hence may need a redesign and optimization of the original system architecture to support model inference e\ufb03ciently. SageDB[35] proposes to learn various database system components by integrating RL and other ML techniques. Nevertheless, the proposed model-driven database system is yet to be fully implemented and benchmarked. It is likely that the data system architecture needs to be overhauled or signi\ufb01cantly amended in order to graft data-driven RL solutions into the data system seamlessly to yield an overall performance gain. 5.1.4 Reproducibility and Benchmark In the data system optimization problem, RL algorithms are not easy to be reproduced due to many factors such as lacking open source codes, workload, historic statistics used, and the unstable performance of RL algorithms. The landscape of problems in system 28 \foptimization is vast and diverse. It could prevent fair comparison and optimization for future research works and deployments in practice. Lacking benchmarks is another challenge to evaluate these RL approaches. The benchmarks are therefore to provide standardized environments and evaluation metrics to conduct experiments with di\ufb00erent RL approaches. There are some e\ufb00orts to mitigate the issue. For example, Park[57] is an open platform for researchers to conduct experiments with RL. However, it only provides a basic interface and lacks system speci\ufb01cations. There is much room to improve with regards to the reproducibility and benchmark in order to promote the development and adoption of RL-based methods[30]. 5.2 Open Challenges For Applications 5.2.1 Lack of Adaptability There is a lack of adaptability for methods on a single component of a data pipeline to the whole. For example, many works focus on data cleaning tasks such as entity matching. However, little works have shown their e\ufb03ciency in deploying their model in an end-to-end data pipeline. These works treat the tasks isolatedly from other tasks in the pipeline, thereby limiting the pipeline\u2019s performance. In healthcare, each method is applied in di\ufb00erent steps of the whole treatment process, without being integrated and evaluated as one pipeline. One possible direction could be considering DRL as a module in the data pipeline optimization. However, data pipeline optimization has been focusing on models simpler than DRL to enable fast pipeline evaluation [53]. How to e\ufb03ciently incorporate DRL into the data pipeline optimization remains a challenge. 5.2.2 Di\ufb03culty in Comparison with Di\ufb00erent Applications To date, most works with generalized contributions are only evaluated domain-speci\ufb01cally. Research questions are often formulated in their own platform as in E-Commerce. This presents di\ufb03culty in evaluating the methods for di\ufb00erent environments. For example, the confounders modeling hidden causal factors in [83] can also contribute to DRL modeling in E-commerce. This is because modeling customers\u2019 interests are always subject to changing environments and a new environment may contain hidden causal factors. For example, consumers are more willing to buy relevant products for certain situations such as Covid19. Thus a general DRL method is yet to show the robustness and e\ufb00ectiveness under the environment of di\ufb00erent applications. 5.2.3 Lack of Prediction in Multi-modality In healthcare and \ufb01nance, multiple sources of data bring di\ufb00erent perspectives. For example in healthcare, electronic health records, image scans, and medical tests can provide di\ufb00erent features for accurate prediction. In addition, these sources of data with di\ufb00erent sample frequencies provide contextual information for modeling a patient\u2019s visits to the hospital or symptom development. However, most innovations in healthcare focus on one particular source of data. How to integrate the contextual information with multi-modality e\ufb00ectively remains an unsolved di\ufb03cult problem. 5.2.4 Injecting Domain Knowledge in Experience Replay In high-stake applications such as healthcare and \ufb01nance, injecting domain knowledge can make decision making in RL more robust and explainable. One possible way is to inject the 29 \fknowledge of human beings\u2019 experience into an agent\u2019s experience pool as a prior distribution for the policy. For example, in dynamic portfolio optimization, a portfolio manager could have a large source of experience for risk management and pro\ufb01t optimization. Such experience could be useful for warming up the agent\u2019s exploration in the search space. Some works have shown positive e\ufb00ects of domain knowledge injection on selecting important experiences (i.e., transition samples) [79]. Notwithstanding, it remains a big challenge to inject useful and relevant knowledge from the experience into the agent\u2019s experience pool. 5.3 Future Research Directions 5.3.1 Data Structure Design DRL provides an alternative way to \ufb01nd good data structures through feedback instead of designing them based on human knowledge and experience, e.g., decision tree[47] and the qd-tree[116]. These trees are optimized better because they are learned by interacting with the environment. DRL has also been e\ufb00ective in graph designs (e.g., molecular graph[117]). However, large-scale graph generation using DRL is di\ufb03cult and daunting because it involves a huge search space. Generating other important structures using DRL remains to be explored. Idreos et al.[33] propose a Data Alchemist that learns to synthesize data structures by DRL and other techniques including Genetic Algorithms and Bayesian Optimization. In summary, DRL has a role in the design of more e\ufb03cient data structures by interacting and learning from the environment. These indexes have to be adaptive to di\ufb00erent data distributions and workloads. 5.3.2 Interpretability The underlying logic behind the DRL agent is still unknown. In high-risk application areas such as healthcare, the adoption of DRL will be a big issue in the case that these approaches make wrong decisions and people do not know why it happens due to lack of interpretability. Many techniques have been proposed to mitigate the issue and provide interpretability[76]. However, they neglect domain knowledge from related \ufb01elds and applications and the explanations are not e\ufb00ective to human users. To instill con\ufb01dence in the deployment of DRL-based systems in practice, interpretability is an important component and we should avoid treating DRL solutions as black boxes especially in critical applications. 5.3.3 Robustness by Causal Reasoning Modeling real-world applications by DRL inevitably su\ufb00ers from the problem of distribution changes. The real world has independent physical mechanisms that can be seen as di\ufb00erent modules. For example, an image is subjected to the light of the environment. Given the modular property, a structural type of modeling focusing on factorizing the causal mechanisms can extract the invariant causal mechanisms and show robustness cross distribution changes [82]. One research direction towards DRL robust decision making is to perform sampling from past actions from a causal perspective. Given the invariance property of causal mechanisms, past actions can be reused by capturing the invariant mechanisms in a changing environment. 5.3.4 Extension to Other Domains Beyond existing works, many classic problems in the data system and analytics could potentially be solved by DRL. For example, Polyjuice[101] learns the concurrency control 30 \falgorithm for a given workload by de\ufb01ning \ufb01ne-grained actions and states in the context of concurrency control. Though they use an evolutionary algorithm to learn and outperform a simple DRL baseline, we believe that there are huge potentials to further improve DRL for niche applications. Hence, we expect that more problems will be explored and solved with DRL in various domains in the near future. 5.3.5 Towards Intelligent and Autonomous Databases Although DRL algorithms could provide breakthrough performance on many tasks than traditional methods, many issues need to be addressed towards intelligent and autonomous databases. First, database schema could be updated and DRL models trained on the previous snapshots may not work. DRL algorithms need to tackle generalization[72]. Second, it would be so costly and infeasible to train models from scratch for each scenario and setting. Transfer learning from existing models could be a potential way to ease the workload greatly. Third, we have to choose appropriate DRL algorithms automatically, in the same spirit as AutoML. Fourth, current DBMS systems were designed without considering much about the learning mechanism. A radically new DBMS design may be proposed based on the learning-centric architecture. To support intelligent and autonomous database systems, DRL models intelligent behaviors and may provide a solid basis for achieving arti\ufb01cial general intelligence based on reward maximization and trial-and-error experience[88]. 6"
+                },
+                {
+                    "url": "http://arxiv.org/abs/1909.03939v2",
+                    "title": "Deterministic Value-Policy Gradients",
+                    "abstract": "Reinforcement learning algorithms such as the deep deterministic policy\ngradient algorithm (DDPG) has been widely used in continuous control tasks.\nHowever, the model-free DDPG algorithm suffers from high sample complexity. In\nthis paper we consider the deterministic value gradients to improve the sample\nefficiency of deep reinforcement learning algorithms. Previous works consider\ndeterministic value gradients with the finite horizon, but it is too myopic\ncompared with infinite horizon. We firstly give a theoretical guarantee of the\nexistence of the value gradients in this infinite setting. Based on this\ntheoretical guarantee, we propose a class of the deterministic value gradient\nalgorithm (DVG) with infinite horizon, and different rollout steps of the\nanalytical gradients by the learned model trade off between the variance of the\nvalue gradients and the model bias. Furthermore, to better combine the\nmodel-based deterministic value gradient estimators with the model-free\ndeterministic policy gradient estimator, we propose the deterministic\nvalue-policy gradient (DVPG) algorithm. We finally conduct extensive\nexperiments comparing DVPG with state-of-the-art methods on several standard\ncontinuous control benchmarks. Results demonstrate that DVPG substantially\noutperforms other baselines.",
+                    "authors": "Qingpeng Cai, Ling Pan, Pingzhong Tang",
+                    "published": "2019-09-09",
+                    "updated": "2019-11-13",
+                    "primary_cat": "cs.LG",
+                    "cats": [
+                        "cs.LG",
+                        "stat.ML"
+                    ],
+                    "main_content": "Introduction Silver et al. propose the deterministic policy gradient (DPG) algorithm (Silver et al. 2014) that aims to \ufb01nd an optimal deterministic policy that maximizes the expected long-term reward, which lowers the variance when estimating the policy gradient, compared to stochastic policies (Sutton et al. 2000). Lillicrap et al. further combine deep neural networks with DPG to improve the modeling capacity, and propose the deep deterministic policy gradient (DDPG) algorithm (Lillicrap et al. 2015). It is recognized that DDPG has been successful in robotic control tasks such as locomotion and manipulation. Despite the effectiveness of DDPG in these tasks, it suffers from the high sample complexity problem (Schulman et al. 2015). Deterministic value gradient methods (Werbos 1990; Nguyen and Widrow 1990; Jordan and Rumelhart 1992; \u2217The \ufb01rst two authors contributed equally to this work. Copyright c \u20dd2020, Association for the Advancement of Arti\ufb01cial Intelligence (www.aaai.org). All rights reserved. Fairbank 2008) compute the policy gradient through back propagation of the reward along a trajectory predicted by the learned model, which enables better sample ef\ufb01ciency. However, to the best of our knowledge, existing works of deterministic value gradient methods merely focus on \ufb01nite horizon, which are too myopic and can lead to large bias. Stochastic value gradient (SVG) methods (Heess et al. 2015) use the re-parameterization technique to optimize the stochastic policies. Among the class of SVG algorithms, although SVG(1) studies in\ufb01nite-horizon problems, it only uses onestep rollout, which limits its ef\ufb01ciency. Also, it suffers from the high variance due to the importance sampling ratio and the randomness of the policy. In this paper, we study the setting with in\ufb01nite horizon, where both state transitions and policies are deterministic. (Heess et al. 2015) gives recursive Bellman gradient equations of deterministic value gradients, but the gradient lacks of theoretical guarantee as the DPG theorem does not hold in this deterministic transition case. We prove that the gradient indeed exists for a certain set of discount factors. We then derive a closed form of the value gradients. However, the estimation of the deterministic value gradients is much more challenging. The dif\ufb01culty of the computation of the gradient mainly comes from the dependency of the gradient of the value function over the state. Such computation may involve in\ufb01nite times of the product of the gradient of the transition function and is hard to converge. Thus, applying the Bellman gradient equation recursively may incur high instability. To overcome these challenges, we use model-based approaches to predict the reward and transition function. Based on the theoretical guarantee of the closed form of the value gradients in the setting, we propose a class of deterministic value gradients DVG(k) with in\ufb01nite horizon, where k denotes the number of rollout steps. For each choice of k, we use the rewards predicted by the model and the action-value at k + 1 step to estimate of the value gradients over the state, in order to reduce the instability of the gradient of the value function over the state. Different number of rollout steps maintains a trade-off between the accumulated model bias and the variance of the gradient over the state. The deterministic policy gradient estimator can be viewed as a special case arXiv:1909.03939v2  [cs.LG]  13 Nov 2019 \fof this class, i.e., it never use the model to estimate the value gradients, and we refer it to DVG(0). As the model-based approaches are more sample ef\ufb01cient than model-free algorithms (Li and Todorov 2004; Levine and Koltun 2013), and the model-based deterministic value gradients may incur model bias (Wahlstr\u00a8 om, Sch\u00a8 on, and Deisenroth 2015), we consider an essential question: How to combines the model-based gradients and the model-free gradients ef\ufb01ciently? We propose a temporal difference method to ensemble gradients with different rollout steps. The intuition is to ensemble different gradient estimators with geometric decaying weights. Based on this estimator, we propose the deterministic value-policy gradient (DVPG) algorithm. The algorithm updates the policy by stochastic gradient ascent with the ensembled value gradients of the policy, and the weight maintains a trade-off between sample ef\ufb01ciency and performance. To sum up, the main contribution of the paper is as follows: \u2022 First of all, we provide a theoretical guarantee for the existence of the deterministic value gradients in settings with in\ufb01nite horizon. \u2022 Secondly, we propose a novel algorithm that ensembles the deterministic value gradients and the deterministic policy gradients, called deterministic value-policy gradient (DVPG), which effectively combines the model-free and model-based methods. DVPG reduces sample complexity, enables faster convergence and performance improvement. \u2022 Finally, we conduct extensive experiments on standard benchmarks comparing with DDPG, DDPG with modelbased rollouts, the stochastic value gradient algorithm, SVG(1) and state-of-the-art stochastic policy gradient methods. Results con\ufb01rm that DVPG signi\ufb01cantly outperforms other algorithms in terms of both sample ef\ufb01ciency and performance. Related Work Model-based algorithms has been widely studied (Moldovan et al. 2015; Montgomery and Levine 2016; Ha and Schmidhuber 2018; Hafner et al. 2018; Chua et al. 2018; Zhang et al. 2018) in recent years. Model-based methods allows for more ef\ufb01cient computations and faster convergence than model-free methods (Wang and Dietterich 2003; Li and Todorov 2004; Levine and Koltun 2013; Watter et al. 2015). There are two classes of model-based methods, one is to use learned model to do imagination rollouts to accelerate the learning. (Gu et al. 2016; Kurutach et al. 2018) generate synthetic samples by the learned model. PILCO (Deisenroth and Rasmussen 2011) learns the transition model by Gaussian processes and applies policy improvement on analytic policy gradients. The other is to use learned model to get better estimates of action-value functions. The value prediction network (VPN) uses the learned transition model to get a better target estimate (Oh, Singh, and Lee 2017). (Feinberg et al. 2018; Buckman et al. 2018) combines different modelbased value expansion functions by TD(k) trick or stochastic distributions to improve the estimator of the action-value function. Different from previous model-based methods, we present a temporal difference method that ensembles model-based deterministic value gradients and model-free policy gradients. Our technique can be combined with both the imagination rollout technique and the model-based value expansion technique. Preliminaries A Markov decision process (MDP) is a tuple (S, A, p, r, \u03b3, p0), where S and A denote the set of states and actions respectively. p(st+1|st, at) represents the conditional density from state st to state st+1 under action at. The density of the initial state distribution is denoted by p0(s). At each time step t, the agent interacts with the environment with a deterministic policy \u00b5\u03b8. We use r(st, at) to represent the immediate reward, contributing to the discounted overall rewards from state s0 following \u00b5\u03b8, denoted by J(\u00b5\u03b8) = E[P\u221e k=0 \u03b3kr(ak, sk)|\u00b5\u03b8, s0]. Here, \u03b3 \u2208[0, 1) is the discount factor. The Q-function of state st and action at under policy \u00b5\u03b8 is denoted by Q\u00b5\u03b8(st, at) = E[P\u221e k=t \u03b3k\u2212tr(ak, sk)|\u00b5\u03b8, st, at]. The corresponding value function of state st under policy \u00b5\u03b8 is denoted by V \u00b5\u03b8(st) = Q\u00b5\u03b8(st, \u00b5\u03b8(st)). We denote the density at state s \u2032 after t time steps from state s following the policy \u00b5\u03b8 by p(s, s \u2032, t, \u00b5\u03b8) . We denote the discounted state distribution by \u03c1\u00b5\u03b8(s \u2032) = R S P\u221e t=1 \u03b3t\u22121p0(s)p(s, s \u2032, t, \u00b5\u03b8)ds. The agent aims to \ufb01nd an optimal policy that maximizes J(\u00b5\u03b8). Deterministic Value Gradients In this section, we study a setting of in\ufb01nite horizon with deterministic state transition, which poses challenges for the existence of deterministic value gradients. We \ufb01rst prove that under proper condition, the deterministic value gradient does exist. Based on the theoretical guarantee, we then propose a class of practical algorithms by rolling out different number of steps. Finally, we discuss the difference and connection between our proposed algorithms and existing works. Deterministic Policy Gradient (DPG) Theorem (Silver et al. 2014), proves the existence of the deterministic policy gradient for MDP that satis\ufb01es the regular condition, which requires the probability density of the next state p(s \u2032|s, a) to be differentiable in a. In the proof of the DPG theorem, the existence of the gradient of the value function is \ufb01rstly proven, i.e., \u2207\u03b8V \u00b5\u03b8(s) = Z S \u221e X t=0 \u03b3tp(s, s\u2032, t, \u00b5\u03b8)\u2207\u03b8\u00b5\u03b8(s\u2032) \u2207a\u2032Q\u00b5\u03b8(s\u2032, a\u2032)|a\u2032=\u00b5\u03b8(s\u2032)ds\u2032, (1) then the gradient of the long-terms rewards exists. Without this condition, the arguments in the proof of the DPG theorem do not work 1, and poses challenges for cases where the differentiability is not satis\ufb01ed. Note this condition does not hold in any case with deterministic transitions. Therefore, one must need a new theoretical guarantee to determine the 1Readers can refer to http://proceedings.mlr.press/v32/silver14supp.pdf \fexistence of the gradient of V \u00b5\u03b8(s) over \u03b8 in deterministic state transition cases. Deterministic value gradient theorem We now analyze the gradient of a deterministic policy. Denote T(s, a) the next state given current state s and action a. Without loss of generality, we assume that the transition function T is continuous, differentiable in s and a and is bounded. Note that the regular condition is not equivalent to this assumption. Consider a simple example that a transition T(s, a) = s + a, then the gradient of p(s\u2032|s, a) over a is in\ufb01nite or does not exist. However, the gradient of T(s, a) over a exists. By de\ufb01nition, \u2207\u03b8V \u00b5\u03b8(s) =\u2207\u03b8 \u0010 r (s, \u00b5\u03b8(s)) + \u03b3V \u00b5\u03b8(s \u2032)|s\u2032=T (s,\u00b5\u03b8(s)) \u0011 =\u2207\u03b8r(s, \u00b5\u03b8(s)) + \u03b3\u2207\u03b8V \u00b5\u03b8(s \u2032)|s\u2032=T (s,\u00b5\u03b8(s)) + \u03b3\u2207\u03b8T(s, \u00b5\u03b8(s))\u2207s\u2032V \u00b5\u03b8(s \u2032). Therefore, the key of the existence (estimation) of the gradient of V \u00b5\u03b8(s) over \u03b8 is the existence (estimation) of \u2207sV \u00b5\u03b8(s). In Theorem 1, we give a suf\ufb01cient condition of the existence of \u2207sV \u00b5\u03b8(s). Theorem 1 For any policy \u00b5\u03b8, the gradient of the value function over the state, \u2207sV \u00b5\u03b8(s), exists with two assumptions: \u2022 A.1: The set of states that the policy visits starting from any initial state s is \ufb01nite. \u2022 A.2: For any initial state s, by Assumption A.1, we get that there is a periodic loop of visited states. Let (s0, s1, ..., sk) denote the loop, and A(s) = \u03b3k+1 Qk i=0 \u2207siT(si, \u00b5\u03b8(si)), the power sum of A(s), P\u221e m=0 Am(s) converges. Proof 1 By de\ufb01nition, V \u00b5\u03b8(s) = r(s, \u00b5\u03b8(s)) + \u03b3V \u00b5\u03b8(s \u2032)|s\u2032=T (s,\u00b5\u03b8(s)). (2) Taking the gradient of Eq. (2), we obtain \u25bdsV \u00b5\u03b8(s) = \u25bds r(s, \u00b5\u03b8(s)) +\u03b3 \u25bds T(s, \u00b5\u03b8(s)) \u25bds\u2032 V \u00b5\u03b8(s \u2032)|s\u2032=T (s,\u00b5\u03b8(s)). (3) Unrolling Eq. (3) with in\ufb01nite steps, we get \u25bdsV \u00b5\u03b8(s) = \u221e X t=0 \u03b3tg(s, t, \u00b5\u03b8) \u25bdst r(st, \u00b5\u03b8(st)), (4) where g(s, t, \u00b5\u03b8) = Qt\u22121 i=0 \u25bdsiT(si, \u00b5\u03b8(si)), s0 = s and si is the state after i steps following policy \u00b5\u03b8. With the assumption A.1, we rewrite (4) by the indicator function I(s, s \u2032, t, \u00b5\u03b8) that indicates whether s \u2032 is obtained after t steps from the initial state s following the policy \u00b5\u03b8: \u25bdsV \u00b5\u03b8(s) = \u221e X t=0 X s\u2032\u2208B(s,\u03b8) \u03b3tg(s, t, \u00b5\u03b8)I(s, s \u2032, t, \u00b5\u03b8) \u25bds\u2032 r(s \u2032, \u00b5\u03b8(s \u2032)), (5) Where B(s, \u03b8) is the set of states the policy visits from s. We now prove that for any \u00b5\u03b8, s, s \u2032, the in\ufb01nite sum of gradients, P\u221e t=0 \u03b3tg(s, t, \u00b5\u03b8)I(s, s \u2032, t, \u00b5\u03b8) converges. For each state s\u2032, there are three cases during the process from the initial state s with in\ufb01nite steps: 1. Never visited: P\u221e t=0 \u03b3tg(s, t, \u00b5\u03b8)I(s, s \u2032, t, \u00b5\u03b8) = 0. 2. Visited once: Let ts\u2032 denote the number of steps that it takes to reach the state s\u2032, then P\u221e t=0 \u03b3tg(s, t, \u00b5\u03b8)I(s, s \u2032, t, \u00b5\u03b8) = \u03b3ts\u2032 g(s, ts\u2032 , \u00b5\u03b8). 3. Visited in\ufb01nite times: Let t1 denote the number of steps it takes to reach s\u2032 for the \ufb01rst time. The state s\u2032 will be revisited every k steps after the previous visit. By de\ufb01nition, \u221e X t=0 \u03b3tg(s, t, \u00b5\u03b8)I(s, s \u2032, t, \u00b5\u03b8) = \u221e X a=0 \u03b3t1g(s, t1, \u00b5\u03b8)Aa(s). (6) By the assumption A.2 we get (6) converges. By exchanging the order of the limit and the summation, \u25bdsV \u00b5\u03b8(s) = X s\u2032\u2208B(s,\u03b8) \u221e X t=0 \u03b3tg(s, t, \u00b5\u03b8)I(s, s \u2032, t, \u00b5\u03b8) \u25bds\u2032 r(s \u2032, \u00b5\u03b8(s \u2032)). (7) Assumption A.1 guarantees the existence of the stationary distribution of states theoretically. Actually, it holds on most continuous tasks, e.g., InvertedPendulum-v2 in MuJoCo. We directly test a deterministic policy with a 2-layer fully connected network on this environment with 10,000 episodes2, and we count the number that each state is visited. After projecting the data into 2D space by t-SNE (Maaten and Hinton 2008), we obtain the state visitation density countour as shown in Figure 1. We have two interesting \ufb01ndings: (1) The set of states visited by the policy is \ufb01nite. (2) Many states are visited for multiple times, which justi\ufb01es Assumption A.1. By the analysis of Assumption A.2, we get that for any policy and state, there exists a set of discount factors such that the the gradient of the value function over the state exists, as illustrated in Corollary 1. Please refer to Appendix A for the proof. Corollary 1 For any policy \u00b5\u03b8 and any initial state s, let (s0, s1, ..., sk) denote the loop of states following the policy and the state, C(s, \u00b5\u03b8, k) = Qk i=0 \u2207siT(si, \u00b5\u03b8(si)), the gradient of the value function over the state, \u2207sV \u00b5\u03b8(s) exists if \u03b3k+1 max {||C(s, \u00b5\u03b8, k)||\u221e, ||C(s, \u00b5\u03b8, k)||1} < 1. In Theorem 2, we show that the deterministic value gradients exist and obtain the closed form based on the analysis in Theorem 1. Please refer to Appendix B for the proof. Theorem 2 (Deterministic Value Gradient Theorem) For any policy \u00b5\u03b8 and MDP with deterministic state transitions, 2We test different weights, the observation of \ufb01nite visited states set is very common among different weights. \fFigure 1: State visitation density countour on InvertedPendulum-v2. if assumptions A.1 and A.2 hold, the value gradients exist, and \u2207\u03b8V \u00b5\u03b8(s) = X s\u2032\u2208B(s,\u03b8) \u03c1\u00b5\u03b8(s, s\u2032)\u2207\u03b8\u00b5\u03b8(s\u2032)(\u2207a\u2032r(s\u2032, a\u2032)+ \u03b3\u2207a\u2032T(s\u2032, a\u2032)\u2207s\u2032\u2032 V \u00b5\u03b8(s \u2032\u2032)|s\u2032\u2032=T (s\u2032,a\u2032)), where a\u2032 is the action the policy takes at state s\u2032, \u03c1\u00b5\u03b8(s, s\u2032) is the discounted state distribution starting from the state s and the policy, and is de\ufb01ned as \u03c1\u00b5\u03b8(s, s\u2032) = P\u221e t=1 \u03b3t\u22121I(s, s\u2032, t, \u00b5\u03b8). Deterministic value gradient algorithm The value gradient methods estimate the gradient of value function recursively (Fairbank and Alonso 2012): \u2207\u03b8V \u00b5\u03b8(s) =\u2207\u03b8r(s, \u00b5\u03b8(s)) + \u03b3\u2207\u03b8T(s, \u00b5\u03b8(s))\u2207s\u2032V \u00b5\u03b8(s\u2032) + \u03b3\u2207\u03b8V \u00b5\u03b8(s\u2032) (8) \u25bdsV \u00b5\u03b8(s) = \u25bds r(s, \u00b5\u03b8(s)) + \u03b3 \u25bds T(s, \u00b5\u03b8(s)) \u25bds\u2032 V \u00b5\u03b8(s \u2032)|s\u2032=T (s,\u00b5\u03b8(s)). (9) In fact, there are two kinds of approaches for estimating the gradient of the value function over the state, i.e., in\ufb01nite and \ufb01nite. On the one hand, directly estimating the gradient of the value function over the state recursively by Eq. (9) for in\ufb01nite times is slow to converge. On the other hand, estimating the gradient by \ufb01nite horizon like traditional value gradient methods (Werbos 1990; Nguyen and Widrow 1990; Heess et al. 2015) may cause large bias of the gradient. We set out to estimate the action-value function denoted by Qw(s, a) with parameter w, and replace \u2207sV \u00b5\u03b8(s) by \u2207sQw(s, \u00b5\u03b8(s)) in Eq. (8). In this way, we can directly obtain a 1-step estimator of the value gradients, G1(\u00b5\u03b8, s) =\u2207\u03b8r(s, \u00b5\u03b8(s)) + \u03b3\u2207\u03b8T(s, \u00b5\u03b8(s)) \u2207s1Qw(s1, \u00b5\u03b8(s1)) + \u03b3G1(\u00b5\u03b8, s1), (10) where s1 is the next state of s, which can be generalized to k(k \u22652) rollout steps. Let si denote the state visited by the policy at the i-th step starting form the initial state s0, g(s, t, \u00b5\u03b8, T) = Qt\u22121 i=1 \u2207siT(si, \u00b5\u03b8(si)). We choose to rollout k \u22121 steps to get rewards, then replace \u2207skV \u00b5\u03b8(sk) by \u2207skQw(sk, \u00b5\u03b8(sk)) in Eq. (9), and we get Lk(\u00b5\u03b8, s, r, T) = k\u22121 X t=1 \u03b3t\u22121g(s, t, \u00b5\u03b8, T)\u2207str(st, \u00b5\u03b8(st)) + \u03b3k\u22121g(s, k, \u00b5\u03b8, T)\u2207skQw(sk, \u00b5\u03b8(sk)). Replacing \u2207s\u2032V \u00b5\u03b8(s\u2032) with Lk(\u00b5\u03b8, s, r, T) in Eq. (8), we get a k-step estimator of the value gradients: Gk(\u00b5\u03b8, s) =\u2207\u03b8r(s, \u00b5\u03b8(s)) + \u03b3\u2207\u03b8T(s, \u00b5\u03b8(s) Lk(\u00b5\u03b8, s, r, T) + \u03b3Gk(\u00b5\u03b8, s1). (11) It is easy to see that Gk(\u00b5\u03b8, s) and G1(\u00b5\u03b8, s) are the same if we have the true reward and transition functions, which is generally not the case as we need to learn the model in practical environments. Let Dk(\u00b5\u03b8, s, T \u2032, r\u2032) denote the value gradient at the sampled state s with k rollout steps, on learned transition function T \u2032 and reward function r\u2032, which is de\ufb01ned as: Dk(\u00b5\u03b8, s, T \u2032, r\u2032) =\u2207\u03b8r\u2032(s, \u00b5\u03b8(s)) + \u03b3\u2207\u03b8T \u2032(s, \u00b5\u03b8(s)) Lk(\u00b5\u03b8, s, r\u2032, T \u2032). (12) Based on Eq.(12), we propose the deterministic value gradients with in\ufb01nite horizon, where the algorithm is shown in Algorithm 1: given n samples (sj, aj, rj, sj+1), for each choice of k, we use 1 n P j Dk(\u00b5\u03b8, sj, T \u2032, r\u2032) to update the current policy. We use sample-based methods to estimate the deterministic value gradients. For each state in the trajectory, we take the analytic gradients by the learned model. As the model is not given, we choose to predict the reward function and the transition function. We choose to use experience replay to compare with the DDPG algorithm fairly. Different choices of the number of rollout steps trade-off between the variance and the bias. Larger steps means lower variance of the value gradients, and larger bias due to the accumulated model error. The difference between in\ufb01nite and \ufb01nite horizon In this section, we discuss the advantage of our proposed DVG algorithm over \ufb01nite horizon and validate the effect on a continuous control task. The estimator of deterministic value gradients with \ufb01nite horizon, DVGF, is de\ufb01ned as (Fairbank and Alonso 2012): Fk(\u00b5\u03b8, s) =\u2207\u03b8r(s, \u00b5\u03b8(s)) + \u03b3\u2207\u03b8T(s, \u00b5\u03b8(s)) k\u22121 X t=1 \u03b3t\u22121 g(s, t, \u00b5\u03b8, T)\u2207str(st, \u00b5\u03b8(st)) + \u03b3Fk(\u00b5\u03b8, s1). Note that Fk(\u00b5\u03b8, s) does not take rewards after the k-th step into consideration. Therefore, given n samples {(sj, aj, rj, sj+1)}, DVGF uses the sample \fAlgorithm 1 The DVG(k) algorithm 1: Initialize the reward network r\u2032, transition network T \u2032, critic network Q, actor network \u00b5\u03b8, target networks Q\u2032, \u00b5\u2032 \u03b8 and experience replay buffer B 2: for episode= 0, ..., N \u22121 do 3: for t = 1, ..., T do 4: Select action according to the current policy and exploration noise 5: Execute action at, observe reward rt and new state st+1, and store transition (st, at, rt, st+1) in B 6: Sample a random minibatch of n transitions from B 7: Update the critic Q by minimizing the TD error: 1 n Pn j (rj + \u03b3Q\u2032(sj+1, \u00b5\u03b8(sj+1)) \u2212Q(sj, aj))2 8: Update the reward network r\u2032 and the transition network T \u2032 on the batch by minimizing the square loss 9: Estimate the value gradients by 1 n P j Dk(\u00b5\u03b8, sj, T \u2032, r\u2032) and perform gradient update on the policy 10: Update the target networks by \u03b8Q \u2032 = \u03c4\u03b8Q + (1 \u2212 \u03c4)\u03b8Q \u2032 ; \u03b8\u00b5 \u2032 = \u03c4\u03b8\u00b5 + (1 \u2212\u03c4)\u03b8\u00b5 \u2032 11: end for 12: end for mean of D\u2032 k(\u00b5\u03b8, s, T \u2032, r\u2032) to update the policy, where D\u2032 k(\u00b5\u03b8, s, T \u2032, r\u2032) is de\ufb01ned as: D\u2032 k(\u00b5\u03b8, s, T \u2032, r\u2032) =\u2207\u03b8r\u2032(s, \u00b5\u03b8(s)) + \u03b3\u2207\u03b8T \u2032(s, \u00b5\u03b8(s)) k\u22121 X t=1 \u03b3t\u22121g(s, t, \u00b5\u03b8, T \u2032)\u2207s\u2032 tr(s \u2032 t, \u00b5\u03b8(s \u2032 t)). We then test the two approaches on the environment HumanoidStandup-v2, where we choose the parameter k to be 23. As shown in Figure 2, DVG signi\ufb01cantly outperforms DVGF, which validates our claim that only considering \ufb01nite horizon fails to achieve the same performance as that of in\ufb01nite horizon. 0 200000 400000 600000 800000 1000000 Steps 50000 60000 70000 80000 90000 100000 110000 Return HumanoidStandup-v2 DVG DVGF Figure 2: Comparisons of DVG and DVGF. 3For the choice of k, we test DVGF with steps ranging from 1 to 5, and we choose the parameter with the best performance for fair comparison. 0 200000 400000 600000 800000 1000000 Steps 100 200 300 400 500 600 700 800 Return Hopper-v2 DVG(1) DVG(3) DVG(5) DDPG Figure 3: Comparisons of DVG with DDPG. Connection and comparison of DVG and DDPG By the proof of the DPG theorem in (Silver et al. 2014), Eq. (8) can be re-written as \u2207\u03b8V \u00b5\u03b8(s) = \u2207\u03b8\u00b5\u03b8(s)\u2207aQ\u00b5\u03b8(s, a) + \u03b3\u2207\u03b8V \u00b5\u03b8(s1). (13) The DDPG algorithm uses the gradient of the estimator of the Q function over the action, \u2207aQw(s, a) to estimate \u2207aQ\u00b5\u03b8(s, a), i.e., G0(\u00b5\u03b8, s) = \u2207\u03b8\u00b5\u03b8(s)\u2207aQw(s, a)+ \u03b3G0(\u00b5\u03b8, s1). The DDPG algorithm is a model-free algorithm which does not predict the reward and the transition, and can be viewed as the DVG(0) algorithm. We compare the DVG algorithm with different rollout steps k and DDPG on a continuous control task in MuJoCo, Hopper-v2. From Figure 3, we get that DVG with any choice of the number of rollout steps is more sample ef\ufb01cient than DDPG, which validates the power of modelbased techniques. DVG(1) outperforms DDPG and DVG with other number of rollout steps in terms of performance as it trades off well between the bias and the variance of the value gradients. Note that with a larger number of step, DVG(5) is not stable due to the propagated model error. The DVPG Algorithm As discussed before, the model-based DVG algorithm are more sample ef\ufb01cient than the model-free DDPG algorithm. However, it suffers from the model bias which results in performance loss. In this section, we consider to ensemble these different gradient estimators for better performance. Motivated by the idea of TD(\u03bb) algorithm (Sutton and Barto 2018), which ensembles the TD(k) error with a geometric decaying weight \u03bb, we propose a temporal-difference method to ensemble DVG with varying rollout steps and the model-free deterministic policy gradients. We de\ufb01ned the temporal difference deterministic value gradients as G\u03bb,t(\u00b5\u03b8, s) = (1 \u2212\u03bb) Pt k=0 \u03bbkGk(\u00b5\u03b8, s), where t denotes the maximal number of rollout steps by the learned model. For the gradient update rule, we also apply sample based methods: given n samples {(sj, aj, rj, sj+1)}, we use 1 n X j ((1 \u2212\u03bb)\u2207\u03b8\u00b5\u03b8(sj)\u2207aQw(sj, a) + (1 \u2212\u03bb) t X k=1 \u03bbkDk(\u00b5\u03b8, sj, T \u2032, r\u2032)) (14) \fto update the policy. Based on this ensembled deterministic value-policy gradients, we propose the deterministic valuepolicy gradient algorithm, shown in Algorithm 2 4. Algorithm 2 The DVPG algorithm 1: Initialize the weight \u03bb and the number of maximal steps t 2: Initialize the reward network r\u2032, transition network T \u2032, critic network Q, actor network \u00b5\u03b8, target networks Q\u2032, \u00b5\u2032 \u03b8 and experience replay buffer B 3: for episode= 0, ..., N \u22121 do 4: for t = 1, ..., T do 5: Select action according to the current policy and exploration noise 6: Execute action at, observe reward rt and new state st+1, and store transition (st, at, rt, st+1) in B 7: Sample a random minibatch of n transitions from B 8: Update the critic Q by minimizing the TD error: 1 n Pn j (rj + \u03b3Q\u2032(sj+1, \u00b5\u03b8(sj+1)) \u2212Q(sj, aj))2 9: Update the reward network r\u2032 and the transition network T \u2032 on the batch by minimizing the square loss 10: Estimate the value gradients by Eq. (14), and perform gradient update on the policy 11: Update the target networks by \u03b8Q \u2032 = \u03c4\u03b8Q + (1 \u2212 \u03c4)\u03b8Q \u2032 ; \u03b8\u00b5 \u2032 = \u03c4\u03b8\u00b5 + (1 \u2212\u03c4)\u03b8\u00b5 \u2032 12: end for 13: end for Experimental Results We design a series of experiments to evaluate DVG and DVPG. We investigate the following aspects: (1) What is the effect of the discount factor on DVG? (2) How sensitive is DVPG to the hyper-parameters? (3) How does DVPG compare with state-of-the-art methods? We evaluate DVPG in a number of continuous control benchmark tasks in OpenAI Gym based on the MuJoCo (Todorov, Erez, and Tassa 2012) simulator. The implementation details are referred to Appendix C. We compare DVPG with DDPG, DVG, DDPG with imagination rollouts (DDPG(model)), and SVG with 1 step rollout and experience replay (SVG(1)) in the text. We also compare DVPG with methods using stochastic policies, e.g. ACKTR, TRPO, in Appendix D. We plot the averaged rewards of episodes over 5 different random seeds with the number of real samples, and the shade region represents the 75% con\ufb01dence interval. We choose the same hyperparameters of the actor and critic network for all algorithms. The prediction models of DVPG, DVG and DDPG(model) are the same. The effect of discount factors on DVG From Eq. (9), we get that \u2207sV \u00b5\u03b8(s) is equivalent to the in\ufb01nite sum of the gradient vectors. To study the effect of the discount factor on DVG, we train the algorithm with 2 rollout steps with different values of the discount factor on the environment InvertedPendulum-v2. As shown in Figure 5, 0.95 performs the best in terms of rewards and stability while 4The only difference between the DVG(k) algorithm and the DVPG algorithm is the update rule of the policy. 0.85 and 0.99 performs comparably, while the performance of 0.8 and 0.6 are inferior to other values. This is because the convergence of the computation of the gradient of the value function over the state may be slow if the discount factor is close to 1 while a smaller value of \u03b3 may enable better convergence of \u2207sV \u00b5\u03b8(s). However, the sum of rewards discounted by a too small \u03b3 will be too myopic, and fails to perform good. Here, 0.95 trades-off well between the stability and the performance, which is as expected that there exists an optimal intermediate value for the discount factor. 0 200000 400000 600000 800000 1000000 Steps 0 100 200 300 400 500 600 Return InvertedPendulum-v2 = 0.6 = 0.8 = 0.85 = 0.95 = 0.99 Figure 5: The effect of discount factors. Ablation study of DVPG We evaluate the effect of the weight of bootstrapping on DVPG with different values from 0.1 to 0.9, where the number of rollout steps is set to be 4. From Figure 6, we get that the performance of the DVPG decreases with the increase of the value \u03bb, where 0.1 performs the best in terms of the sample ef\ufb01ciency and the performance. Thus, we choose the value of the weight to be 0.1 in all experiments. 0 200000 400000 600000 800000 1000000 Steps 0 1000 2000 3000 4000 Return HalfCheetah-v2 DVPG_0.1 DVPG_0.3 DVPG_0.5 DVPG_0.7 DVPG_0.9 Figure 6: The weight of bootstrapping. We evaluate the effect of the number of rollout steps ranging from 1 to 5. Results in Figure 7 show that DVPG with different number of rollout steps all succeed to learn a good policy, with 1 rollout step performing the best. Indeed, the number of rollout steps trade off between the model-error and the variance. There is an optimal value of the number of rollout steps for each environment, which is the only one parameter we tune. To summarize, for the number of look steps, 1 rollout step works the best on Humanoid-v2, Swimmer-v2 and HalfCheetah-v2, while 2 rollout steps performs the best on HumanoidStandup-v2, Hopper-v2 and Ant-v2. For fair \f0 200000 400000 600000 800000 1000000 Steps 40000 60000 80000 100000 120000 Return HumanoidStandup-v2 0 200000 400000 600000 800000 1000000 Steps 0 200 400 600 800 1000 Return Hopper-v2 0 200000 400000 600000 800000 1000000 Steps 1500 1000 500 0 500 Return Ant-v2 0 200000 400000 600000 800000 1000000 Steps 0 50 100 150 200 Return Swimmer-v2 0 200000 400000 600000 800000 1000000 Steps 0 1000 2000 3000 4000 Return HalfCheetah-v2 DVPG DVG DDPG DDPG(Model) SVG(1) 0 200000 400000 600000 800000 1000000 Steps 200 400 600 800 1000 1200 Return Humanoid-v2 Figure 4: Performance comparisons on environments from the MuJoCo simulator. comparisons, we choose the same number of rollout steps for both the DVG and the DVPG algorithm. 0 200000 400000 600000 800000 1000000 Steps 0 1000 2000 3000 4000 Return HalfCheetah-v2 DVPG_1 DVPG_2 DVPG_3 DVPG_4 DVPG_5 Figure 7: The number of rollout steps. Performance comparisons In this section we compare DVPG with the model-free baseline DDPG, and model-based baselines including DVG, DDPG(model) and SVG(1) on several continuous control tasks on MuJoCo. As shown in Figure 8, there are two classes of comparisons. Firstly, we compare DVPG with DDPG and DVG to validate the effect of the temporal difference technique to ensemble model-based and model-free deterministic value gradients. The DVG algorithm is the most sample ef\ufb01cient than other algorithms in environments HumanoidStandup-v2, and Hopper-v2. For sample ef\ufb01ciency, DVPG outperforms DDPG as it trades off between the model-based deterministic value gradients and the model-free deterministic policy gradients. In the end of the training, DVPG outperforms other two algorithms signi\ufb01cantly, which demonstrates the power of the temporal difference technique. In other four environments, DVPG outperforms other algorithms in terms of both sample ef\ufb01ciency and performance. The performance of DVG and DDPG on Swimmer-v2 and Ant-v2 are comparable, while DVG performs bad in Halfcheetah-v2 and Humanoid-v2 due to the model-error. Secondly, we compare DVPG with SVG(1) and DDPG with imagination rollouts. Results show that the DVPG algorithm signi\ufb01cantly outperforms these two model-based algorithms in terms of sample ef\ufb01ciency and performance, especially in environments where other model-based algorithms do not get better performance than the model-free DDPG algorithm. For the performance of the SVG(1) algorithm, it fails to learn good policies in Ant-v2, which is also reported in (Kurutach et al. 2018)."
+                },
+                {
+                    "url": "http://arxiv.org/abs/1906.06639v1",
+                    "title": "Reinforcement Learning Driven Heuristic Optimization",
+                    "abstract": "Heuristic algorithms such as simulated annealing, Concorde, and METIS are\neffective and widely used approaches to find solutions to combinatorial\noptimization problems. However, they are limited by the high sample complexity\nrequired to reach a reasonable solution from a cold-start. In this paper, we\nintroduce a novel framework to generate better initial solutions for heuristic\nalgorithms using reinforcement learning (RL), named RLHO. We augment the\nability of heuristic algorithms to greedily improve upon an existing initial\nsolution generated by RL, and demonstrate novel results where RL is able to\nleverage the performance of heuristics as a learning signal to generate better\ninitialization.\n  We apply this framework to Proximal Policy Optimization (PPO) and Simulated\nAnnealing (SA). We conduct a series of experiments on the well-known\nNP-complete bin packing problem, and show that the RLHO method outperforms our\nbaselines. We show that on the bin packing problem, RL can learn to help\nheuristics perform even better, allowing us to combine the best parts of both\napproaches.",
+                    "authors": "Qingpeng Cai, Will Hang, Azalia Mirhoseini, George Tucker, Jingtao Wang, Wei Wei",
+                    "published": "2019-06-16",
+                    "updated": "2019-06-16",
+                    "primary_cat": "cs.LG",
+                    "cats": [
+                        "cs.LG",
+                        "stat.ML"
+                    ],
+                    "main_content": "INTRODUCTION Combinatorial optimization [15] aims to find the optimal solution with the minimum cost from a finite set of candidates to discrete problems such as the bin packing problem, the traveling salesman problem, or integer programming. Combinatorial optimization has seen broad applicability in fields ranging from telecommunications network design, to task scheduling, to transportation systems planning. As many of these combinatorial optimization problems are NP-complete, optimal solutions cannot be tractably found [3]. Heuristic algorithms such as simulated annealing (SA) [1, 11, 14] are designed to search for the optimal solution by randomly perturbing candidate solutions and accepting those that satisfy some greedy criterion such as Metropolis-Hastings. Heuristics are widely used in combinatorial optimization problems such as Concorde for the traveling salesman problem, or METIS for graph partitioning [2, 5]. Some heuristic algorithms like SA are theoretically guaranteed to find the optimal solution to a problem given a low enough temperature and enough perturbations [4]. However, the framework for heuristic algorithms begins the solution search from a randomly initialized candidate solution. For example, in the bin packing problem, the initial solution fed into SA would be a random assignment of objects to bins, which would then be repeatedly perturbed until convergence. Starting hill climbing from a cold start is time-consuming and limits the applicability of heuristic algorithms on practical problems. Reinforcement learning (RL) has been proposed as a technique to yield efficient solutions to combinatorial optimization problems by first learning a policy, and then using it to generate a solution to the problem. RL has seen interesting applications in real world combinatorial optimization problems [8, 16]. However, RL lacks the theoretical guarantees of algorithms like SA, which use a hillclimbing approach and are less susceptible to problems like policy collapse. By setting the greedy criterion to only accept better solutions, SA can achieve monotonically better performance, whereas RL cannot. Thus, it is best to generate an initial solution using RL and continuously improve this solution using heuristic algorithms like SA. Furthermore, it is advantageous for RL to learn how to provide an optimal initialization to SA to maximize the performance of both techniques in tandem. In this paper, we address these two points by introducing the Reinforcement Learning Driven Heuristic Optimization Framework (RLHO), shown in Figure 1. There are two components in this arXiv:1906.06639v1  [cs.LG]  16 Jun 2019 \fDRL4KDD \u201919, August 5, 2019, Anchorage, AK, USA Q. Cai et al. Figure 1: The RLHO framework. framework: the RL agent and the heuristic optimizer (HO). The RL agent generates solutions that act as initialization for HO, and HO searches for better solutions starting from the solution generated by RL. After HO finishes executing (upon convergence or after a set number of search steps), it returns the found solution and the reward to the RL agent. Our learning process is an alternating loop of (1) generating initial solutions with RL and then (2) searching for better solutions with HO. To the RL agent, HO is part of the environment. We apply RLHO to the bin packing problem where the RL agent is modeled using Proximal Policy Optimization (PPO) [13] and HO is simulated annealing (SA). We demonstrate that not only does combining PPO and SA yield superior performance to PPO alone, but also that PPO is actually able to learn to generate better initialization for SA. By observing the end performance of SA on a problem, PPO can generate inputs to SA that improve the performance of SA itself. In summary, our contributions in this paper are as follows: \u2022 We demonstrate a novel approach to combinatorial optimization where reinforcement learning and heuristic algorithms are combined to yield superior results to reinforcement learning alone on a combinatorial optimization problem. \u2022 We demonstrate that we can train reinforcement learning to enable heuristic algorithms to achieve superior performance than when they are decoupled on a combinatorial optimization problem. 1.1 Related Work Reinforcement learning and evolutionary algorithms achieve competitive performance on MuJoCo tasks and Atari games [12]. The idea of applying evolutionary algorithms to reinforcement learning [9] has been widely studied. [6] proposes a framework to apply evolutionary strategies to selectively mutate a population of reinforcement learning policies. [7, 10] use a gradient method to enhance evolution. Our work is different from the above as we apply deep reinforcement learning to generate better initializations for heuristic algorithms. The heuristic part in the RLHO framework only changes the solution, rather than the parameters of the policy. To our knowledge, our work is the first that does this. 2 COMBINING PPO AND SA 2.1 Preliminary Discussion What is the best way to combine an RL agent and a heuristic algorithm? A first approach is to allow an RL agent to generate an initial solution to a combinatorial optimization problem, then execute a heuristic algorithm to refine this initial solution until convergence, and then train the RL policy with the rewards obtained from the performance of the heuristic algorithm. This would delineate one episode. However, on large problems, heuristics take a long time to converge. Thus, in our approach, we allow the heuristic algorithm to run for a only limited number of steps in one episode. We now introduce the RLHO algorithm. 2.2 The RLHO Algorithm Our approach is a two-stage process as detailed in Algorithm 1: at the start of each episode, first run RL for x steps to generate an initial solution sx. Then, run pure HO for y steps starting from sx. Finally we update RL with the cost of the final solution. We repeat this process with a fresh start every time. Our action space is designed as perturbing the currently available solution. In our bin packing problem discussed in more detail in Section 3, the agent is first presented with a randomly initialized assignment s0 of items to bins. The environment around the bin packing problem will then present the agent with an item i. The agent then needs to decide which other item j to swap locations with item i based on the current state. For the design of the reward function, we define the intermediate reward as the difference between the cost of the previous solution and the cost of the current solution, as the goal is to minimize cost. When the agent\u2019s action space consists of perturbations, the MDP for the combinatorial optimization problem results in an infinite horizon. We are not privileged with V (sterm) = 0 that would normally denote the terminal state of the MDP. The agent is free to continue perturbing the state forever, and thus, V (sterm) is undefined. However, our agents are trained with a finite number of steps x, so V (sx) would normally need to be estimated with a baseline such as a value function. The value function is a poor estimator because it does not accurately estimate the additional expected performance of the agent in the limit of time, because we simply don\u2019t possess such data. To address this, a novelty in our approach is to obtain a better estimate for V (sx) using the performance of HO. The additional optimization provided by HO gives us an additional training signal to RL as to how RL actions contribute to the future return provided by HO. Therefore, RL can be trained by two signals in RLHO: (1) the intermediate reward at each RL step, and (2) the discounted future reward provided by HO conditioned on the initialization provided by RL. This approach provides RL with a training signal to generate better initialization for HO. V (st ) = x\u22121 \u00d5 k=t \u03b3 krk + \u221e \u00d5 k=x \u03b3 krk = x\u22121 \u00d5 k=t \u03b3 krk + V (sx). (1) \fReinforcement Learning Driven Heuristic Optimization DRL4KDD \u201919, August 5, 2019, Anchorage, AK, USA As shown in Equation (1), we can replace the infinite horizon term with a stationary, tractable value V (sx). We obtain V (sx) by running pure HO for y steps starting from sx, and then taking the difference between the cost of sx and the cost of the final solution sx+y as an estimate for the value of V (sx). Algorithm 1 The RLHO algorithm Initialize the replay buffer B and the solution randomly Initialize the number of RL steps x and the number of SA steps y in one episode for iteration = 1, 2, ... do Rollout using RL policy for x steps and store the transitions in B, obtaining initial solution sx from RL Run HO on sx for y steps to obtain sx+y Get the new reward rn as the difference of costs of sx and sx+y Train RL using V (sx) Reset the solution and hyperparameters of HO end for Algorithm 2 Simulated Annealing Initialize the temperature T = tm, the maximal number of steps of SA in one path, y q = 0, a = \u2212ln( tm t0 ) Obtain the PPO solution sx for t = 1, 2, ...,y do Perturb the current solution sx+t randomly, get s\u2032 x+t if cost(s\u2032 x+t ) > cost(sx+t ) then Reject s\u2032 x+t with probability p = 1 \u2212e\u2212(c(s\u2032)\u2212c(s))/T else sx+t+1 = s\u2032 x+t end if T = tmeaq/y q = q + 1 end for 3 PERFORMANCE EVALUATION We validate our methods on the bin packing problem. In this section we first introduce the bin packing problem, and then discuss the performance gain obtained when combining the RL part (PPO) and the heuristic optimizer (SA) in our RLHO framework. The details of SA are shown in Algorithm 2. 3.1 The Bin Packing Problem Bin packing is a classical combinatorial optimization problem where the objective is to use the minimum number of bins to pack items of different sizes, with the constraint that the sum of sizes of items in one bin is bounded by the size of the bin. Let n denote the number of bins and the number of items, and v denote the vector representing the of sizes of all items. Let xij be the 0/1 matrix that represents one assignment of items to bins (a packing), i.e., xij = 1 means the item j is put in the bin i. Given a packing x, let c(x) denote the cost, the number of bins used in this solution, i.e., c(x) = \u00cdn i=1 \u00cdn j=1 xij. 3.2 Learning to Generate Better Initializations We evaluate the ability of RLHO to generate better initializations for heuristic algorithms. In this set of experiments, during training, we allow RLHO to generate an initialization using RL for x timesteps, and then run HO using y timesteps. After N training episodes, we take the initialization generated by the RL step of RLHO and use it to initialize a HO that will run until convergence. Table 1 and Table 2 count the average number of used bins of the best solution during training with x = 128,y = 5000,tm = 5 and x = 128,y = 50000,tm = 5 respectively, over 5 independent trials. We also report results where random perturbations (Random) are used instead of RL to generate the initial solutions as a baseline. We collect results for 10000 iterations of running RLHO and Random until convergence. Our results show that RLHO does learn better initializations for HO than Random, and the performance gap increases with larger problem sizes. The training signal provided by the HO performance used to augment the value function indeed does help RLHO allow heuristic algorithms to perform better. Most interestingly, when the RL part of RLHO is trained using signal from SA that is run for 5000 steps, the initialization it generates is still effective for SA that runs until convergence, e.g. millions of timesteps. n RLHO Random, then HO 100 59 69 200 128.4 141 500 347 361 1000 714 734 Table 1: Average cost of the best solution found by each algorithm with y = 5000/50000 HO steps. n RLHO Random, then HO 100 59 69 200 127 141 500 344.4 359 1000 711 731 Table 2: Average cost of the best solution found by each algorithm with y = 50000 HO steps. 3.3 Having RL and HO Work Together Now we extend our experimental evaluation to answer the following question: can HO help RL train better? Can running HO after an RL training step help RL explore better states? We adjust RLHO to perform alternating optimization on a combinatorial optimization problem. RL will generate a solution, which will then be optimized by HO. RL will then be trained with additional signal from HO. The same solution will then be passed back to RL for continuous optimization. This differs from our previous approach because we do not reset the solution on each episode. The greedy nature of HO will perform hill climbing, allowing RL to see more optimal states throughout training. \fDRL4KDD \u201919, August 5, 2019, Anchorage, AK, USA Q. Cai et al. n RL RLHO 50 22 22 100 50 50 200 102 101 500 283 266 1000 613 601 Table 3: Average cost of the best solution found by each algorithm with x = 128,y = 1000 n RL RLHO 50 22 22 100 50 50 200 102 101 500 283 265 1000 613 572 Table 4: Average cost of the best solution found by each algorithm with x = 128,y = 5000 Figure 2: Training performance on 500bins. We run the two algorithms side-by-side to evaluate our approach. Table 3 and Table 4 show the average number of used bins of the best solution (over 5 independent runs) searched by both algorithms during training. For RL, we simply keep running PPO without any SA. In RLHO, PPO learns from SA. We choose to set x = 128, y = 1000 and the initial temperature of SA to be 5. We compare the performance of two algorithms in terms of the number of steps the RL policy performs, with the hyperparameters of the RL part of both approaches kept constant. We also evaluate our approaches on different sizes of the bin packing problem. We report the results until 2000 iterations run for the alternating optimization. The convergence curves of all approaches are shown in Figure 2. We conclude that the pure RL algorithm is more sample efficient but performs worse as the RL algorithm has no additional outlet for exploration. RLHO achieves better performance because it adopts the HO to perform better exploration. 4"
+                },
+                {
+                    "url": "http://arxiv.org/abs/1807.03708v3",
+                    "title": "Deterministic Policy Gradients With General State Transitions",
+                    "abstract": "We study a reinforcement learning setting, where the state transition\nfunction is a convex combination of a stochastic continuous function and a\ndeterministic function. Such a setting generalizes the widely-studied\nstochastic state transition setting, namely the setting of deterministic policy\ngradient (DPG).\n  We firstly give a simple example to illustrate that the deterministic policy\ngradient may be infinite under deterministic state transitions, and introduce a\ntheoretical technique to prove the existence of the policy gradient in this\ngeneralized setting. Using this technique, we prove that the deterministic\npolicy gradient indeed exists for a certain set of discount factors, and\nfurther prove two conditions that guarantee the existence for all discount\nfactors. We then derive a closed form of the policy gradient whenever exists.\nFurthermore, to overcome the challenge of high sample complexity of DPG in this\nsetting, we propose the Generalized Deterministic Policy Gradient (GDPG)\nalgorithm. The main innovation of the algorithm is a new method of applying\nmodel-based techniques to the model-free algorithm, the deep deterministic\npolicy gradient algorithm (DDPG). GDPG optimize the long-term rewards of the\nmodel-based augmented MDP subject to a constraint that the long-rewards of the\nMDP is less than the original one.\n  We finally conduct extensive experiments comparing GDPG with state-of-the-art\nmethods and the direct model-based extension method of DDPG on several standard\ncontinuous control benchmarks. Results demonstrate that GDPG substantially\noutperforms DDPG, the model-based extension of DDPG and other baselines in\nterms of both convergence and long-term rewards in most environments.",
+                    "authors": "Qingpeng Cai, Ling Pan, Pingzhong Tang",
+                    "published": "2018-07-10",
+                    "updated": "2018-10-02",
+                    "primary_cat": "cs.LG",
+                    "cats": [
+                        "cs.LG",
+                        "stat.ML"
+                    ],
+                    "main_content": "Introduction Reinforcement learning has been one of the most successful computational tools for solving complex decision making problems [29], with extensive applications in both discrete tasks such as general game playing [17, 18] and continuous control tasks such as robotics [10]. In contrast to the traditional value-based methods [31, 35, 17, 18] that are meant for solving problems with discrete and low-dimensional action space, policy gradient methods [23, 30] aim to tackle these limitations, by optimizing a parameterized policy via estimating the gradient of the expected long-term reward, using gradient ascent. [26] propose the deterministic policy gradient (DPG) algorithm that aims to \ufb01nd an optimal deterministic policy, which lowers the variance when estimating the policy gradient [39], compared to stochastic policies [30]. It is shown that the algorithm can be applied to domains with continuous and high-dimensional action spaces. [15] further propose the deep deterministic policy gradient (DDPG) algorithm, by combining deep neural networks to improve convergence. It is recognized that DDPG has been successful in robotic control tasks such as locomotion [27] and manipulation [7]. Despite the e\ufb00ectiveness of DDPG in these tasks, it is limited for problems with stochastic continuous state transitions. Here, the continuity means that the probability density of the next state is continuous in the action taken at the current state. In fact, many important control problems, such as MountainCar, Pendulum [2], and autonomous driving, include both stochastic and deterministic state transitions. For example, in most autonomous driving tasks, state transitions are deterministic under normal driving conditions, yet are still stochastic due to sudden disturbances. As a result, DDPG, which assumes stochastic state transitions, does not generalize well in practice. Tasks with deterministic state transitions pose serious technical challenges due to the discontinuity of the transition function, where the gradient of the transition probability density function over actions does not always exist. [37, 5, 9] consider the gradient of the value function over states and the deterministic policy gradient in the setting of deterministic state transitions, but the existence of the value function\u2019s gradient over states and the deterministic policy gradient is not studied. Lacking of theoretical guarantees for the existence of the gradient limits the applicability of deterministic policy gradient algorithms. As a result, an important question for policy gradient based methods is, Does the gradient exist in settings with deterministic state transitions? If yes, can one solve the problem e\ufb03ciently by its gradient? In this paper, we study a generalized setting, where the state transition is a convex combination of a stochastic continuous transition function and a deterministic discontinuous transition function. As a result, it includes both the stochastic case and the deterministic case as special cases. Our setting is arguably closer to the mixed control problems mentioned above than those stochastic settings. We \ufb01rst give a simple example to illustrate that the deterministic policy gradient may be in\ufb01nite under deterministic state transitions. Then we introduce a new theoretical technique to prove the existence of the policy gradient in this 2 \fgeneralized setting. Using this technique, we prove that the deterministic policy gradient indeed exists for a certain set of discount factors. We further present two conditions that guarantee the existence for all discount factors. We then derive a closed form of the policy gradient. However, the estimation of the deterministic policy gradient is much more challenging due to the sample complexity of model-free algorithms [25] and complex state transitions. As for the state transition, the di\ufb03culty of the computation of the gradient mainly comes from the dependency of the policy gradient and the gradient of the value function over the state. Such computation may involve in\ufb01nite times of sampling the whole state space. Thus applying DDPG directly in a general setting even with low-dimensional state space may incur high sample complexity. To overcome these challenges, we approximate the original Markov decision process (MDP) by a model-based augmented MDP with the same reward function and the transition function being the expectation of original MDP. By the form of the deterministic policy gradient with deterministic state transitions, we get that the model-based augmented MDP has a simple structure, which allows for more e\ufb03cient computations and faster convergence than model-free methods [14, 13, 36]. Unfortunately, applying this mode-based technique directly does not help to solve environments with large continuous state space as it is hard to represent the transition dynamics [34]. This leads to an essential question: How to apply the model-based technique to deterministic policy gradient algorithms e\ufb00ectively? We then consider a program that maximizes the long-term rewards of the augmented MDP with the constraint that its long-term rewards is less than that of the original MDP. The intuition is that we choose a objective with less sample complexity to optimize, and it serves as a lower bound of the original objective. Note that the improvement of the new objective, guarantees the improvement of the original objective. As the constrainted problem is hard to optimize, we choose to optimize the Lagrangian dual function of the program, which can be interpreted as a weighted objective between the long-term reward of the original MDP and the augmented MDP. Based on this dual function, we propose the Generalized Deterministic Policy Gradient (GDPG) algorithm. The algorithm updates the policy by stochastic gradient ascent with the gradient of the weighted objective over the parameter of the policy, and the weight maintains a trade-o\ufb00 between fast convergence and performance. To sum up, the main contribution of the paper is as follows: \u2022 First of all, we provide a theoretical guarantee for the existence of the gradient in settings with deterministic state transitions. \u2022 Secondly, we propose a novel policy gradient algorithm, called Generalized Deterministic Policy Gradient (GDPG), which combines the model-free and model-based methods. GDPG reduces sample complexity, enables faster convergence and performance improvement. \u2022 Finally, we conduct extensive experiments on standard benchmarks com3 \fparing with state-of-the-art stochastic policy gradient methods including TRPO [25], ACKTR [38] and the direct model-based extension of DDPG, called MDPG. Results con\ufb01rm that GDPG signi\ufb01cantly outperforms other algorithms in terms of both convergence and performance. 2 Preliminaries A Markov decision process (MDP) is a tuple (S, A, p, r, \u03b3, p1), where S and A denote the set of states and actions respectively. Let p(st+1|st, at) represent the conditional density from state st to state st+1 under action at, which satis\ufb01es the Markov property, i.e., p(st+1|s0, a0, ..., st, at) = p(st+1|st, at). The density of the initial state distribution is denoted by p0(s). At each time step t, the agent interacts with the environment with a deterministic policy \u00b5\u03b8, which is parameterized by \u03b8. We use r(st, at) to represent the corresponding immediate reward, contributing to the discounted overall rewards from state s0 following \u00b5\u03b8, denoted by J(\u00b5\u03b8) = E[P\u221e k=0 \u03b3kr(ak, sk)|\u00b5\u03b8, s0]. Here, \u03b3 \u2208[0, 1] is the discount factor. The Q-function of state st and action at under policy \u00b5\u03b8 is denoted by Q\u00b5\u03b8(st, at) = E[P\u221e k=t \u03b3k\u2212tr(ak, sk)|\u00b5\u03b8, st, at]. The corresponding value function of state st under policy \u00b5\u03b8 is denoted by V \u00b5\u03b8(st) = Q\u00b5\u03b8(st, \u00b5\u03b8(st)). We denote the density at state s \u2032 after t time steps from state s by p(s, s \u2032, t, \u00b5\u03b8) following the policy \u00b5\u03b8. We denote the (improper) discounted state distribution by \u03c1\u00b5\u03b8(s \u2032) = R S P\u221e t=1 \u03b3t\u22121p0(s)p(s, s \u2032, t, \u00b5\u03b8)ds. The agent aims to \ufb01nd an optimal policy that maximizes J(\u00b5\u03b8). 2.1 Why is the DPG theorem not applicable for deterministic state transitions? An important property of the DPG algorithms is the Deterministic Policy Gradient Theorem [26], \u25bd\u03b8J(\u00b5\u03b8) = R S \u03c1\u00b5\u03b8(s)(\u25bd\u03b8\u00b5\u03b8(s) \u25bda Q\u00b5\u03b8(s, a)|a=\u00b5\u03b8(s))ds, which proves the existence of the deterministic policy gradient. The DPG theorem holds under the regular condition presented by [26], i.e., p(s \u2032|s, a) is continuous in a. The arguments in the proof of the DPG theorem do not work without this condition1. Now we give a simple example to show the policy gradient is in\ufb01nite for some discount factors. Example 2.1. Given a MDP with two dimensional state spaces and action spaces, whose transition and reward functions are de\ufb01ned by T(s, a) = (2s1 + 2s2 + a1, 2s1 + 2s2 + a2)T , r(s, a) = \u2212sT a. Consider a deterministic policy \u00b5\u03b8(s) = \u03b8, then \u25bdsT(s, \u00b5\u03b8(s)) = \u00142 2 2 2 \u0015 , and \u25bdsV \u00b5\u03b8(s) = \u2212(I + P\u221e n=1 \u03b3n \u001422n\u22121 22n\u22121 22n\u22121 22n\u22121 \u0015 )\u03b8. Then \u25bdsV \u00b5\u03b8(s) converges if and only if \u03b3 < 1/4. 1Readers can refer to http://proceedings.mlr.press/v32/silver14-supp.pdf 4 \fOne must need a new technique to determine the existence of the gradient of J(\u00b5\u03b8) over \u03b8 in irregular cases. 3 Deterministic State Transitions In this section we study a simple setting where the state transition is a deterministic function. As discussed before, the DPG theorem does not apply to this setting. To analyze the gradient of a deterministic policy, we let T(s, a) denote the next state given the current state s and the action a. Without loss of generality, we assume that T(s, a), \u25bdaT(s, a), \u25bdsT(s, a), r(s, a), \u25bdsr(s, a), \u25bdar(s, a) are all continuous in s and a and bounded. By de\ufb01nition, \u25bd\u03b8V \u00b5\u03b8(s) = \u25bd\u03b8(r(s, \u00b5\u03b8(s)) + \u03b3V \u00b5\u03b8(s \u2032)|s\u2032=T (s,\u00b5\u03b8(s))). Thus the key of the existence of the gradient of V \u00b5\u03b8(s) over \u03b8 is the existence of \u25bdsV \u00b5\u03b8(s). Now we give a su\ufb03cient condition of the existence of \u25bdsV \u00b5\u03b8(s). Lemma 1. For any policy \u00b5\u03b8, let n denote the dimension of the state, and c be the maximum of the max norm of all Jacobain matrices, maxs || \u25bds T(s, \u00b5\u03b8(s))||max, for any discount factor \u03b3 in [0, 1 nc), \u25bdsV \u00b5\u03b8(s) exists. Proof. By de\ufb01nition, V \u00b5\u03b8(s) = Q\u00b5\u03b8(s, \u00b5\u03b8(s)) = r(s, \u00b5\u03b8(s))+\u03b3V \u00b5\u03b8(s \u2032)|s\u2032=T (s,\u00b5\u03b8(s))). Then \u25bdsV \u00b5\u03b8(s) = \u25bdsr(s, \u00b5\u03b8(s)) + \u03b3 \u25bds T(s, \u00b5\u03b8(s)) \u25bds\u2032 V \u00b5\u03b8(s \u2032)|s\u2032=T (s,\u00b5\u03b8(s)). (1) By unrolling (1) with in\ufb01nite steps, we get \u25bdsV \u00b5\u03b8(s) = \u221e X t=0 Z S \u03b3tg(s, t, \u00b5\u03b8)I(s, s \u2032, t, \u00b5\u03b8) \u25bds\u2032 r(s \u2032, \u00b5\u03b8(s \u2032))ds \u2032, where I(s, s \u2032, t, \u00b5\u03b8) is an indicator function that indicates whether s \u2032 is obtained after t steps from the state s following the policy \u00b5\u03b8. Here, g(s, t, \u00b5\u03b8) = Qt\u22121 i=0 \u25bdsiT(si, \u00b5\u03b8(si)), where s0 = s and si is the state after i steps following policy \u00b5\u03b8. The state transitions and policies are both deterministic. We now prove that for any \u00b5\u03b8, s, s \u2032 and \u03b3 \u2208[0, 1 nc), A(s) = P\u221e t=0 \u03b3tg(s, t, \u00b5\u03b8)I(s, s \u2032, t, \u00b5\u03b8) converges. We describe the proof sketch here and the complete proof is referred to Appendix A. For each state s\u2032, which is reached from the initial state s with in\ufb01nite steps, there are three cases due to deterministic state transitions: never visited, visited once, and visited in\ufb01nite times. It is easy to see that A(s) converges in the \ufb01rst two cases. In the last case, as A(s) is the sum of the power of the matrix \u03b3t2g(s, t2, \u00b5\u03b8), then we get a upper bound of \u03b3 such that A(s) converges. By Lebesgue\u2019s Dominated Convergence Theorem [24], we exchange the order of the limit and the integration, \u25bdsV \u00b5\u03b8(s) = R S P\u221e t=0 \u03b3tg(s, t, \u00b5\u03b8)I(s, s \u2032, t, \u00b5\u03b8) \u25bds\u2032 r(s \u2032, \u00b5\u03b8(s \u2032))ds \u2032. By the continuity of T, r and \u00b5\u03b8, the gradient of V \u00b5\u03b8(s) over s exists. 5 \fNote that the condition proposed in Lemma 1 is indeed necessary in Example 2.1, where n = 2, c = 2 and the gradient exists if and only if the discount factor \u03b3 < 1/4. By Lemma 1, we show that the deterministic policy gradient exists and obtain the closed form. The proof is referred to Appendix B. Theorem 1. For any policy \u00b5\u03b8 and MDP with deterministic state transitions, for any discount factor \u03b3 in [0, 1 nc), the policy gradient exists, and \u25bd\u03b8J(\u00b5\u03b8) = Z S \u03c1\u00b5\u03b8(s)\u25bd\u03b8\u00b5\u03b8(s)(\u25bdar(s, a)|a=\u00b5\u03b8(s)+\u03b3\u25bdaT(s, a)|a=\u00b5\u03b8(s)\u25bds\u2032 V \u00b5\u03b8(s \u2032)|s\u2032=T (s,a))ds. 4 Deterministic Policy Gradients with general state transitions In this section we consider a general setting where the state transition for any state s and any action a is a convex combination of a deterministic transition function T(s, a) with probability f(s, a), and a stochastic probability transition density function p(s \u2032|s, a) with probability 1 \u2212f(s, a). Note that this setting generalizes that of DPG. Here, T also satis\ufb01es the same condition as in Section 3. We assume that f(s, a), \u25bdsf(s, a) and \u25bdaf(s, a) are continuous and bounded. By the similar technique to the setting with deterministic state transitions, we get the main theorem which proves the existence of the gradient of J(\u00b5\u03b8) over \u03b8 for a set of discount factors and proposes two conditions such that for all discount factors the policy gradient exists: Condition A.1: maxs f(s, \u00b5\u03b8(s)) \u2264 1 nc. Condition A.2: For any sequence of states (s0, ..., st\u22121) and any timestep t, the eigenvalues of Qt\u22121 i=0 f(si, \u00b5\u03b8(si)) \u25bdsi T(si, \u00b5\u03b8(si)) are in [\u22121, 1]. Theorem 2. The GDPG Theorem For any MDP in the general cases and any policy \u00b5\u03b8, for any discount factor \u03b3 in [0, 1 nc maxs f(s,\u00b5\u03b8(s))), the policy gradient exists. If the MDP satis\ufb01es Condition A.1 or Condition A.2, for any discount factor and any policy \u00b5\u03b8, the policy gradient exists. The form is \u25bd\u03b8J(\u00b5\u03b8) = Z S \u03c1\u00b5\u03b8(s)(\u25bd\u03b8\u00b5\u03b8(s) \u25bda r(s, a)|a=\u00b5\u03b8(s) + \u03b3f(s, \u00b5\u03b8(s)) \u25bd\u03b8 \u00b5\u03b8(s) \u25bda T(s, a)|a=\u00b5\u03b8(s) \u25bds\u2032 V \u00b5\u03b8(s \u2032)|s\u2032=T (s,a) + \u03b3(1 \u2212f(s, \u00b5\u03b8(s))) Z S \u25bd\u03b8\u00b5\u03b8(s) \u25bda p(s \u2032|s, a)|a=\u00b5\u03b8(s) V \u00b5\u03b8(s \u2032)ds \u2032 + \u03b3 \u25bd\u03b8 f(s, \u00b5\u03b8(s))V \u00b5\u03b8(s \u2032)|s\u2032=T (s,\u00b5\u03b8(s)) \u2212\u03b3 \u25bd\u03b8 f(s, \u00b5\u03b8(s)) Z S p(s \u2032|s, a)|a=\u00b5\u03b8(s)V \u00b5\u03b8(s \u2032)ds \u2032)ds = Z S \u03c1\u00b5\u03b8(s)(\u25bd\u03b8\u00b5\u03b8(s) \u25bda Q\u00b5\u03b8(s, a)|a=\u00b5\u03b8(s))ds. (2) The proof is referred to Appendix C. It is interesting to note that the form is the same as the form of gradient of DPG. In fact, the assumption of the condition 6 \fA.1 and A.2 would become weaker when the probability of the deterministic state transition becomes lower. In the extreme case, i.e., the stochastic case, where the probability is zero, the policy gradient exists without any assumption as in [26]. In fact, the form of the policy gradient is the same in settings of the deterministic state transition and the general case. However, given an estimator of the value function, the complexity of calculating the gradient of these two cases is di\ufb00erent. By comparing (1) with (2), we get that it is the more computationally expensive for the gradient of the general case than the deterministic case. The gradient of deterministic state transitions only involves \u25bd\u03b8r(s, \u00b5\u03b8(s)) and \u25bds\u2032 V \u00b5\u03b8(s \u2032), while the gradient of the general case introduces additional integration on the state space. 4.1 Direct Model-based Extension of DDPG As discussed before, even for the environment with low-dimensional state space, the sample complexity of DDPG is signi\ufb01cantly high for the general case, which may limit the capability of the model-free algorithms due to slow convergence. Thus, we consider a model-based augmented MDP M\u2217of the original MDP M with the same reward function, while the state transition function is de\ufb01ned as the expectation of the distribution of the next state of the original MDP, i.e., T\u2217(s, a) = E[s \u2032|s, a]. M\u2217is easier to solve as the state transition of M\u2217is deterministic. Note that if the environment is indeed deterministic, M\u2217= M. Now we de\ufb01ne a direct model-based extension of DDPG, called MDPG. MDPG directly uses the gradient of the long-term rewards of M\u2217with policy \u00b5\u03b8 to improve the policy instead of the deterministic policy gradient, i.e., \u25bd\u03b8J\u2217(\u00b5\u03b8) = \u00b5\u03b8(s) \u25bda Q\u00b5\u03b8 \u2217(s, a), where Q\u00b5\u03b8 \u2217(s, a) denotes the action value function of the augmented MDP. However, it is hard to represent the transition dynamics in complex environments, and it may cause the policy to move to a wrong direction as shown in Section 5.2 on problems with large state space. 4.2 The GDPG Algorithm On the one hand, only solving the model-based augmented MDP may be too myopic. On the other hand, the model-free algorithm su\ufb00ers from high sample complexity as mentioned. Consequently, we consider a program that maximizes the long-term rewards of the augmented MDP, with the constraint being that the long-term rewards of the augmented MDP is less than the original MDP, i.e., max \u03b8 J\u2217(\u00b5\u03b8), s.t.J\u2217(\u00b5\u03b8) \u2264J(\u00b5\u03b8). (3) It is easy to check that the optimum of this program is less than max\u03b8 J(\u00b5\u03b8), and it serves as a lower bound of the long-term rewards of the original MDP. The intuition of this program is to optimize a model-based objective which is easier to solve and the improvement of the new objective guarantees the improvement of the original objective. 7 \fAlgorithm 1: GDPG algorithm 1 Initialize a positive weight \u03b1 2 Initialize the transition network T(s, a|\u03b8T ) with random weights \u03b8T 3 Initialize the original and augmented critic networks Q(s, a|\u03b8Q), Q\u2217(s, a|\u03b8Q\u2217) with random weights \u03b8Q, \u03b8Q\u2217 4 Initialize the actor network \u00b5(s|\u03b8\u00b5) with random weights \u03b8\u00b5 5 Initialize the target networks Q \u2032, Q\u2217 \u2032 and \u00b5 \u2032 with weights \u03b8Q \u2032 = \u03b8Q, \u03b8Q \u2032 \u2217= \u03b8Q\u2217, \u03b8\u00b5 \u2032 = \u03b8\u00b5 6 Initialize Experience Replay bu\ufb00er B 7 for episode= 0, ..., N \u22121 do 8 Initialize a random process N for action exploration 9 Receive initial observation state s0. 10 for t = 1, ..., T do 11 Select action at = \u00b5(st|\u03b8\u00b5) + Nt according to the current policy and exploration noise 12 Execute action at, observe reward rt and new state st+1, and store transition (st, at, rt, st+1) in B 13 Sample a random minibatch of N transitions (si, ai, ri, si+1) from B 14 Set yi = ri + \u03b3Q \u2032(si+1, \u00b5 \u2032(si+1|\u03b8\u00b5 \u2032 )|\u03b8Q \u2032 ) 15 Update the critic Q by minimizing the loss: L1 = 1 N P i (yi \u2212Q(si, ai|\u03b8Q)) 2 16 Set y \u2032 i = ri + \u03b3Q \u2032 \u2217(T(si, ai|\u03b8T ), \u00b5 \u2032(T(si, ai|\u03b8T )|\u03b8\u00b5 \u2032 )|\u03b8Q \u2032 \u2217) 17 Update the augmented critic Q\u2217by minimizing the loss: L2 = 1 N P i (y \u2032 i \u2212Q\u2217(si, ai|\u03b8Q\u2217)) 2 18 Upate the transition T by minimizing the loss: L3 = 1 N P i (si+1 \u2212T(si, ai|\u03b8T )) 2 19 Update the actor by the sampled policy gradient and target networks: \u25bd\u03b8\u00b5J(\u03b8\u00b5) = 1 N X i (1 \u2212\u03b1) \u25bd\u03b8\u00b5 \u00b5(s|\u03b8\u00b5) \u25bda Q\u2217(s, a|\u03b8Q\u2217) + \u03b1 \u25bd\u03b8\u00b5 \u00b5(s|\u03b8\u00b5) \u25bda Q(s, a|\u03b8Q) 20 21 \u03b8Q \u2032 = \u03c4\u03b8Q +(1\u2212\u03c4)\u03b8Q \u2032 ; \u03b8Q \u2032 \u2217= \u03c4\u03b8Q\u2217+(1\u2212\u03c4)\u03b8Q \u2032 \u2217; \u03b8\u00b5 \u2032 = \u03c4\u03b8\u00b5 +(1\u2212\u03c4)\u03b8\u00b5 \u2032 8 \fIf the value function is convex in states 2, the long-term rewards of M\u2217with policy \u00b5\u03b8, J\u2217(\u00b5\u03b8) is no larger than the long-term rewards of M, as illustrated in Theorem 3. That is, the program turns into a problem that maximizes the model-based objective. The proof is referred to Appendix D. Theorem 3. If V \u00b5\u03b8(s) is convex in s, J(\u00b5\u03b8) \u2265J\u2217(\u00b5\u03b8). In the other case that the value function is not convex, it is hard to solve the program directly. Therefore, we choose to optimize its Lagrangian dual program, min \u03b1\u22650 max \u03b8 J\u2217(\u00b5\u03b8) + \u03b1(J(\u00b5\u03b8) \u2212J\u2217(\u00b5\u03b8)). (4) Then for each choice of \u03b1, we use the gradient of J\u2217(\u00b5\u03b8) + \u03b1(J(\u00b5\u03b8) \u2212J\u2217(\u00b5\u03b8)), i.e., (1 \u2212\u03b1)\u00b5\u03b8(s) \u25bda Q\u00b5\u03b8 \u2217(s, a) + \u03b1\u00b5\u03b8(s) \u25bda Q\u00b5\u03b8(s, a), (5) which generalizes the gradient of the DDPG algorithm, to improve the policy by stochastic gradient ascent, where Q\u00b5\u03b8 \u2217(s, a) denotes the action value function of the augmented MDP. However, the estimation of the value function of the augmented MDP relies on the expectation of the distribution of the next state, which is unknown. To overcome this challenge, we follow the idea of [22], where neural networks are applied to predict the next state. Di\ufb00erent from [22] where they take model predictive control as the control policy, we apply the estimators of state transitions to estimate the action-value function of the augmented MDP. We now propose the Generalized Deterministic Policy Gradient (GDPG) algorithm, as shown in Algorithm 1. Apart from training the actor and the critic, we also train a transition network T which predicts the next state. 5 Experiments In this section, we design a series of experiments to evaluate GDPG. We aim to investigate the following questions: (1) How does the value of \u03b1 a\ufb00ect the performance on a toy problem with general state transitions? (2) How does GDPG compare with DDPG, MDPG, and other state-of-the-art methods on continuous control benchmarks? We \ufb01rst illustrate the in\ufb02uence of the weight \u03b1 in a toy environment, ComplexPoint-v0 with general state transitions. Then we evaluate GDPG in a number of continuous control benchmark tasks in OpenAI Gym [2], including a classic control problem [21] and a task in the Box2D and MuJoCo [33] simulator. The details of our benchmarks are referred to Appendix E. We compare GDPG with the following baselines: (a) DDPG, (b) MDPG, (c) TRPO, (d) ACKTR. For the experiments, we run each algorithm 1M steps on each environment over 5 random seeds. Note that the con\ufb01guration of GDPG is the same as that of DDPG of except for the transition network. Full con\ufb01guration 2The value functions of Linear Quadratic Regulation [1] and Linearly-solvable Markov Decision Process [32] are indeed convex. 9 \fis referred to Appendix E. We use the averaged return of previous 100 episodes as the performance metric. 5.1 The ablation study of GDPG To better understand the e\ufb00ect of \u03b1 in the dual function, we evaluate GDPG with \ufb01ve di\ufb00erent choices of the weight \u03b1 = 0, 0.25, 0.5, 0.75, 1, 2 in ComplexPointv0. Figure 1(a) shows a snapshot of this environment, where the state is the coordinates of the agent in the 5D space while the feasible action set is [\u22120.1, 0.1]5. The state transition is a convex combination of the deterministic transition T(s, a) = s + a with probability f(s, a), and uniform distribution [\u22121, 1]5 with probability 1 \u2212f(s, a), where f(s, a) = ||a||2 2/0.05. The reward function is r(s, a) = \u2212||s + a||2, i.e., the distance between the agent and the origin. The task is terminated either when the agent enters the termination area or the number of steps exceeds a threshold of 100 steps. Figure 1(b) shows the performance comparison, and Figure 1(c) and Figure 1(d) correspond to its earlier stage and convergence stage, which illustrates convergence and performance more clearly. As shown, for \u03b1 = 1, which indeed corresponds to DDPG, results in a bad performance and slow convergence. The slow convergence attributes to the computation complexity of gradient in this environment. For \u03b1 = 0, the goal corresponds to optimize the augmented MDP, which performs better than DDPG as it e\ufb03ciently reduces sample complexity. However, it is too myopic as it solely focuses on the augmented MDP, which may deviate from the original objective and limit its performance. We observe that the best performance is achieved when \u03b1 = 0.5. We can view the weighted objective as a convex combination of the model-free objective and the model-based objective when \u03b1 \u2208[0, 1]. \u03b1 trades-o\ufb00between the convergence and the performance. A large \u03b1 may introduce bias while a small \u03b1 may su\ufb00er from sample complexity. Note that the choice of 2 for the value of \u03b1 achieves the worst performance. Recall (5), the reason is that setting a value of \u03b1 larger than 1 may lead the gradient of the policy to a totally opposite direction and induce large variance of the policy gradient. 5.2 Performance comparison with baselines on continuous control benchmarks We now present and discuss the \ufb01ndings from our experiments on several continuous control tasks, all of which are standard benchmark de\ufb01ned in OpenAI Gym [2]. Tasks range from low-dimensional input space to high-dimensional input space. For the baselines algorithms, we use the implementation from OpenAI Baselines [4]. Figure 2, 3 and 4 show the sample mean and the standard deviation of the averaged returns in each environment. As shown in Figure 2, GDPG outperforms other baselines in tasks with low-dimensional input space including a classic continuous control task and a task simulated by Box2D. From Figure 3 and 4, we observe that GDPG outperforms high-dimensional tasks simulated by MuJoCo by a large margin, especially in Swimmer-v2, HalfCheetah-v2, 10 \f(a) The ComplexPoint environment. 0 200000 400000 600000 800000 1000000 Steps 160 140 120 100 80 60 40 20 Return ComplexPoint-v0 =0 =0.25 =0.5 =0.75 =1 =2 (b) E\ufb00ect of \u03b1. 15000 20000 25000 30000 35000 40000 Steps 135 130 125 120 115 110 105 100 Return Stage 1 =0 =0.25 =0.5 =0.75 =1 (c) Earlier stage. 950000 960000 970000 980000 990000 1000000 Steps 40 38 36 34 32 30 28 26 24 Return Stage 2 =0 =0.25 =0.5 =0.75 =1 (d) Convergence stage. Figure 1: Return/steps of training on algorithms 11 \f0 200000 400000 600000 800000 1000000 Steps 1400 1200 1000 800 600 400 200 Return Pendulum-v0 GDPG DDPG MDPG TRPO ACKTR (a) Pendulum-v0. 0 200000 400000 600000 800000 1000000 Steps 600 400 200 0 200 Return GDPG LunarLanderContinuous-v2 GDPG DDPG MDPG TRPO ACKTR (b) LunarLander-v2. Figure 2: Return/steps of training on environments from the MuJoCo simulator. 0 200000 400000 600000 800000 1000000 Steps 50 0 50 100 150 200 250 Return Swimmer-v2 GDPG DDPG MDPG TRPO ACKTR (a) Swimmer-v2. 0 200000 400000 600000 800000 1000000 Steps 1000 0 1000 2000 3000 4000 5000 Return HalfCheetah-v2 GDPG DDPG MDPG TRPO ACKTR (b) HalfCheetah-v2. Figure 3: Return/steps of training on environments from the MuJoCo simulator. and Humanoid-v2. This demonstrates that GDPG combines the model-based augmented MDP and the original MDP e\ufb03ciently. Note that the direct modelbased extension of DDPG, MDPG performs the worst in all environments except Swimmer-v2. It shows that the model-based technique can not solve complex settings like MuJoCo as it is hard to represent the transition dynamics. 6 Related Work Model-based algorithms has been widely studied [11, 16, 19, 20] in recent years. Iterative LQG [14] applies model-based methods and assumes a speci\ufb01c form of both transition dynamics and the value function while [28, 8, 12] generate synthetic samples by the learned model. Di\ufb00erent from traditional model-based methods, we optimize the dual function that involves the model-based augmented MDP and the original MDP. Perhaps the most related model-based approach to our work is PILCO [3], which learns the transition model by Gaussian processes. 12 \f0 200000 400000 600000 800000 1000000 Steps 40000 60000 80000 100000 120000 Return HumanoidStandup-v2 GDPG DDPG MDPG TRPO ACKTR (a) HumanoidStandup-v2. 0 200000 400000 600000 800000 1000000 Steps 0 200 400 600 800 1000 1200 1400 1600 Return Humanoid-v2 GDPG DDPG MDPG TRPO ACKTR (b) Humanoid-v2. Figure 4: Return/steps of training on environments from the MuJoCo simulator. With the non-parametric transition model, [3] applies policy improvement on analytic policy gradients. However this method does not scale well to nonlinear transition dynamics or high-dimensional state spaces. Di\ufb00erent from [3], we do not rely on assumptions of the transition model. 7"
+                },
+                {
+                    "url": "http://arxiv.org/abs/1708.07607v3",
+                    "title": "Reinforcement Mechanism Design for e-commerce",
+                    "abstract": "We study the problem of allocating impressions to sellers in e-commerce\nwebsites, such as Amazon, eBay or Taobao, aiming to maximize the total revenue\ngenerated by the platform. We employ a general framework of reinforcement\nmechanism design, which uses deep reinforcement learning to design efficient\nalgorithms, taking the strategic behaviour of the sellers into account.\nSpecifically, we model the impression allocation problem as a Markov decision\nprocess, where the states encode the history of impressions, prices,\ntransactions and generated revenue and the actions are the possible impression\nallocations in each round. To tackle the problem of continuity and\nhigh-dimensionality of states and actions, we adopt the ideas of the DDPG\nalgorithm to design an actor-critic policy gradient algorithm which takes\nadvantage of the problem domain in order to achieve convergence and stability.\nWe evaluate our proposed algorithm, coined IA(GRU), by comparing it against\nDDPG, as well as several natural heuristics, under different rationality models\nfor the sellers - we assume that sellers follow well-known no-regret type\nstrategies which may vary in their degree of sophistication. We find that\nIA(GRU) outperforms all algorithms in terms of the total revenue.",
+                    "authors": "Qingpeng Cai, Aris Filos-Ratsikas, Pingzhong Tang, Yiwei Zhang",
+                    "published": "2017-08-25",
+                    "updated": "2018-02-27",
+                    "primary_cat": "cs.MA",
+                    "cats": [
+                        "cs.MA",
+                        "cs.AI"
+                    ],
+                    "main_content": "INTRODUCTION A fundamental problem that all e-commerce websites are faced with is to decide how to allocate the buyer impressions to the potential sellers. When a buyer searches a keyword such as \u201ciPhone 7 rose gold\u201d, the platform will return a ranking of different sellers providing an item that fits the keyword, with different prices and different historical sale records. The goal of the platform is to come up with algorithms that will allocate the impressions to the most appropriate sellers, eventually generating more revenue from the transactions. This setting can be modeled as a resource allocation problem over a sequence of rounds, where in each round, buyers arrive, the algorithm inputs the historical records of the sellers and their prices and outputs such an allocation of impressions. The sellers and the buyers carry out their transactions and the historical records are updated. In reality, most e-commerce websites employ a class of heuristic algorithms, such as collaborative filtering or content based filtering [34], many of which rank sellers in terms of \u201chistorical scores\u201d calculated based on the transaction history of the sellers with buyers of similar characteristics. However, this approach does not typically take into account the fact that sellers strategize with the choice of prices, as certain sub-optimal prices in one round might affect the record histories of sellers in subsequent rounds, yielding more revenue for them in the long run. Even worse, since the sellers are usually not aware of the algorithm in use, they might \u201cexplore\u201d with their pricing schemes, rendering the system uncontrollable at times. It seems natural that a more sophisticated approach that takes all these factors into account should be in place. In the presence of strategic or rational individuals, the field of mechanism design [29] has provided a concrete toolbox for managing or preventing the ill effects of selfish behaviour and achieving desirable objectives. Its main principle is the design of systems in such a way that the strategic behaviour of the participants will lead to outcomes that are aligned with the goals of the society, or the objectives of the designer. Cai et al. [10] tackle the problem of faking transactions and fraudulent seller behaviour in e-commerce using the tools from the field of mechanism design. A common denominator in most of the classical work in economics is that the participants have access to either full information or some distributional estimate of the preferences of others. However, in large and constantly evolving systems like e-commerce websites, the participants interact with the environment in various ways, and arXiv:1708.07607v3  [cs.MA]  27 Feb 2018 \fadjust their own strategies accordingly and dynamically [32]. In addition to that, their rationality levels are often bounded by either computational or financial constraints, or even cognitive limitations [35]. For the reasons mentioned above, a large recent body of work has advocated that other types of agent behaviour, based on learning and exploration, are perhaps more appropriate for such large-scale online problems encountered in reality [13, 18\u201321, 28, 32, 33]. In turn, this generates a requirement for new algorithmic techniques for solving those problems. Our approach is to use techniques from deep reinforcement learning for solving the problem of the impression allocation to sellers, given their selfish nature. In other words, given a rationality model for the sellers, we design reinforcement learning algorithms that take this model into account and solve the impression allocation problem efficiently. This general approach is called reinforcement mechanism design [11, 36, 40], and we can view our contribution in this paper as an instance of this framework. No-regret learning as agent rationality As mentioned earlier, the strong informational assumptions of classical mechanism design are arguably unrealistic in complex and dynamic systems, like diverse online marketplaces. Such repeated game formulations typically require that the participants know the values of their competitors (or that they can estimate them pretty accurately based on known prior distributions) and that they can compute their payoff-maximizing strategies over a long sequence of rounds. Such tasks are usually computationally burdensome and require strong cognitive assumptions, as the participants would have to reason about the future, against all possible choices of their opponents, and in a constantly evolving environment. Given this motivation, an alternative approach in the forefront of much of the recent literature in algorithmic mechanism design is to assume that the agents follow some type of no-regret strategies; the agent picks a probability mixture over actions at each round and based on the generated payoffs, it updates the probabilities accordingly, minimizing the long-term regret. This is more easily conceivable, since the agents only have to reason about their own strategies and their interaction with the environment, and there is a plethora of no-regret algorithms at their disposal. Precisely the same argument has been made in several recent works [13, 21, 28, 32, 33] that study popular auction settings under the same rationality assumptions of no-regret, or similar types. In fact, there exist data from Microsoft\u2019s Ad Actions which suggest that advertisers do use no-regret algorithms for their actions [41]. For a more detailed discussion on related rationality models, the reader is referred to [18]. The seller rationality model: To model the different sophistication levels of sellers, we consider four different models of rationality, based on well-established no-regret learning approaches. The first two, \u03f5-Greedy [43] and \u03f5-First are known as semi-uniform methods, because they maintain a distinction between exploration and exploitation. The later is often referred to as \u201cA/B testing\u201d and is widely used in practice [9, 12]. The other two approaches, UCB1 [2, 5] and Exp3 [5, 6] are more sophisticated algorithms that differ in their assumptions about the nature of the rewards, i.e. whether they follow unknown distributions or whether they are completely adversarial. Note that all of our rationality models employ algorithms for the multi-arm bandit setting, as in platforms like Taobao or eBay, the impression allocation algorithms are unknown to the sellers and therefore they can not calculate the payoffs of unused auctions. The update of the weights to the strategies is based solely on the observed payoffs, which is often referred to as the bandit feedback setting [16]. We note here that while other related rationality models can be used, the goal is to choose a model that real sellers would conceivably use in practice. The semi-uniform algorithms are quite simpler and model a lower degree of seller sophistication, whereas the other two choices correspond to sellers that perhaps put more effort and resources into optimizing their strategies some examples of sophisticated optimization services that are being used by online agents are provided in [28]. Note that both UCB1 and Exp3 are very well-known [9] and the latter is perhaps the most popular bandit feedback implementation of the famous Hedge (or Multiplicative Weights Update) algorithm for no-regret learning in the fully informed feedback setting. The impression allocation problem We model the impression allocation problem as a Markov decision process (MDP) in which the information about the prices, past transactions, past allocations of impressions and generated revenue is stored in the states, and the actions correspond to all the different ways of allocating the impressions, with the rewards being the immediate revenue generated by each allocation. Given that the costs of the sellers (which depend on their production costs) are private information, it seems natural to employ reinforcement learning techniques for solving the MDP and obtain more sophisticated impression allocation algorithms than the heuristics that platforms currently employ. In our setting however, since we are allocating a very large number of impressions, both the state space and the action space are extremely large and high-dimensional, which renders traditional reinforcement learning techniques such as temporal difference learning [38] or more specifically Q-learning [14] not suitable for solving the MDP. In a highly influential paper, Mnih et al. [31] employed the use of deep neural networks as function approximators to estimate the action-value function. The resulting algorithm, coined \u201cDeep Q Network\u201d (DQN), can handle large (or even continuous) state spaces but crucially, it can not be used for large or continuous action domains, as it relies on finding the action that maximizes the Q-function at each step. To handle the large action space, policy gradient methods have been proposed in the literature of reinforcement learning with actor-critic algorithms rising as prominent examples [7, 15, 39], where the critic estimates the Q-function by exploring, while the actor adjusts the parameters of the policy by stochastic gradient ascent. To handle the high-dimensionality of the action space, Silver et al. [37] designed a deterministic actor-critic algorithm, coined \u201cDeterministic Policy Gradient\u201d (DPG) which performs well in standard reinforcement-learning benchmarks such as mountain car, pendulum and 2D puddle world. As Lillicrap et al. [27] point out however, the algorithm falls short in large-scale problems and for \fthat reason, they developed the \u201cDeep-DPG\u201d (DDPG) algorithm which uses the main idea from [31] and combines the deterministic policy gradient approach of DPG with deep neural networks as function approximators. To improve convergence and stability, they employ previously known techniques such as batch normalization [23], target Q-networks [30], and experience replay [1, 22, 31]. The IA(GRU) algorithm: We draw inspiration from the DDPG algorithm to design a new actor-critic policy gradient algorithm for the impression allocation problem, which we refer to as the IA(GRU) algorithm. IA(GRU) takes advantage of the domain properties of the impression allocation problem to counteract the shortcomings of DDPG, which basically lie in its convergence when the number of sellers increases. The modifications of IA(GRU) to the actor and critic networks reduce the policy space to improve convergence and render the algorithm robust to settings with variable sellers, which may arrive and depart in each round, for which DDPG performs poorly. We evaluate IA(GRU) against DDPG as well as several natural heuristics similar to those usually employed by the online platforms and perform comparisons in terms of the total revenue generated. We show that IA(GRU) outperforms all the other algorithms for all four rationality models, as well as a combined pool of sellers of different degrees of sophistication. 2 THE SETTING In the impression allocation problem of e-commerce websites, there are m sellers who compete for a unit of buyer impression.1 In each round, a buyer2 searches for a keyword and the platform returns a ranking of sellers who provide an item that matches the keyword; for simplicity, we will assume that all sellers provide identical items that match the keyword exactly. Each selleri has a private costci for the item, which can be interpreted as a production or a purchasing cost drawn from an i.i.d. distribution Fs. Typically, there are n slots (e.g. positions on a webpage) to be allocated and we let xij denote the probability (or the fraction of time) that seller i is allocated the impression at slot j. With each slot, there is an associated click-through-rate \u03b1j which captures the \u201cclicking potential\u201d of each slot, and is independent of the seller, as all items offered are identical. We let qi = \u00cdn j=1 xij\u03b1j denote the probability that the buyer will click the item of seller i. Given this definition (and assuming that sellers can appear in multiple slots in each page), the usual feasibility constraints for allocations, i.e. for all i, for all j, t holds that 0 \u2264xij \u22641 and or all j, it holds that \u00cdm i=1 xij \u22641 can be alternatively written as for all i,qi \u22650, it holds that m \u00d5 i=1 qi \u2264 n \u00d5 j=1 \u03b1j and n \u00d5 j=1 \u03b1j = 1. That is, for any such allocation q, there is a feasible ranking x that realizes q (for ease of notation, we assume that the sum of clickthrough rates of all slots is 1) and therefore we can allocate the 1Since the buyer impressions to be allocated is a huge number, we model it as a continuous unit to be fractionally allocated. Even if we used a large integer number instead, the traditional approaches like DDPG fall short for the same reasons and furthermore all of the performance guarantees of IA(GRU) extend to that case. 2As the purchasing behavior is determined by the valuation of buyers over the item, without loss of generality we could consider only one buyer at each round. buyer impression to sellers directly instead of outputting a ranking over these items when a buyer searches a keyword.3 Let hit = (vit,pit,nit, \u2113it ) denote the records of seller i at round t, which is a tuple consisting of the following quantities: (1) vit is the expected fraction of impressions that seller i gets, (2) pit is the price that seller i sets, (3) nit is the expected amount of transactions that seller i makes, (4) \u2113it is the expected revenue that seller i makes at round t. Let Ht = (h1t,h2t, ...,hit ) denote the records of all sellers at round t, and let Hit = (hi1,hi2, ...,hit ) denote the vectors of records of seller i from round 1 to round t, which we will refer to as the records of the seller. At each round t + 1, seller i chooses a price pi(t+1) for its item and the algorithm allocates the buyer impression to sellers. MDP formulation: The setting can be defined as a Markov decision process (MDP) defined by the following components: a continuous state space S, a continuous action space A, with an initial state distribution with density p0(s0), and a transition distribution of states with conditional density p(st+1|st,at ) satisfying the Markov property, i.e. p(st+1|s0,a0, ...,st,at ) = p(st+1|st,at ). Furthermore, there is an associated reward function r : S \u00d7 A \u2192R assigning payoffs to pairs of states and actions. Generally, a policy is a function \u03c0 that selects stochastic actions given a state, i.e, \u03c0 : S \u2192P(A), where P(A) is the set of probability distributions on A. Let Rt denote the discounted sum of rewards from the state st , i.e, Rt (st ) = \u00cd\u221e k=t \u03b3 k\u2212tr(sk,ak), where 0 < \u03b3 < 1. Given a policy and a state, the value function is defined to be the expected total discounted reward, i.e. V \u03c0 (s) = E[Rt (st )|st = s; \u03c0] and the action-value function is defined as Q\u03c0 (s,a) = E[Rt (st )|st = s,at = a; \u03c0]. For our problem, a state st of the MDP consists of the records of all sellers in the last T rounds, i.e. st = (Ht\u2212T , ...,Ht\u22121), that is, the state is a (T,m, 4) tensor, the allocation outcome of the round is the action, and the immediate reward is the expected total revenue generated in this round. The performance of an algorithm is defined as the average expected total revenue over a sequence ofT0 rounds. Buyer Behaviour: We model the behaviour of the buyer as being dependent on a valuation that comes from a distribution with cumulative distribution function Fb. Intuitively, this captures the fact that buyers may have different spending capabilities (captured by the distribution). Specifically, the probability that the buyer purchases item i is nit = (1 \u2212Fb(pit )) \u00b7 vit , that is, the probability of purchasing is decided by the impression allocation and the price seller i sets. For simplicity and without loss of generality with respect to our framework, we assume that the buyer\u2019s valuation is drawn from U (0, 1), i.e. the uniform distribution over [0, 1]. Seller Rationality As we mentioned in the introduction, following a large body of recent literature, we will assume that the sellers employ no-regret type strategies for choosing their prices in the next round. Generally, a seller starts with a probability distribution over all the possible prices, and after each round, it observes the payoffs that these 3The framework extends to cases where we need return similar but different items to a buyer, i.e, the algorithm outputs a ranking over these items. Furthermore, our approach extends trivially to the case when sellers have multiple items. \fstrategies generate and adjusts the probabilities accordingly. As we already explained earlier, it is most natural to assume strategies in the bandit feedback setting, where the seller does not observe the payoffs of strategies in the support of its strategy which were not actually used. The reason is that even if we assume that a seller can see the prices chosen in a round by its competitors, it typically does not have sufficient information about the allocation algorithm used by the platform to calculate the payoffs that other prices would have yielded. Therefore it is much more natural to assume that the seller updates its strategy based on the observed rewards, using a multi-arm bandit algorithm. More concretely, the payoff of a seller i that receives vit impressions in round t when using price pij(t), is given by uij(t) = nit (pij(t) \u2212ci) = vit (1 \u2212Fb(pit ))(pij(t) \u2212ci). For consistency, we normalize the costs and the prices to lie in the unit interval [0, 1] and we discretize the price space to a \u201cdense enough\u201d grid (of size 1/K, for some large enough K). This discretization can either be enforced by the platform (e.g. the sellers are required to submit bids which are multiples of 0.05) or can be carried out by the sellers themselves in order to be able to employ the multi-arm bandit algorithms which require the set of actions to be finite, and since small differences in prices are unlikely to make much difference in their payoffs. We consider the following possible strategies for the sellers, based on well-known bandit algorithms. \u03b5-Greedy [43]: With probability \u03b5, each seller selects a strategy uniformly at random and with probability 1 \u2212\u03b5, the strategy with the best observed (empirical) mean payoff so far. The parameter \u03b5 denotes the degree of exploration of the seller, whereas 1 \u2212\u03b5 is the degree of exploitation; here \u03b5 is drawn i.i.d. from the normal distribution N(0.1, 0.1/3). \u03b5-First: For a horizon of T rounds, this strategy consists of an exploration phase first, over \u03b5 \u00b7 T rounds, followed by an exploitation phase, for the remaining period. In the exploration phase, the seller picks a strategy uniformly at random. In the remaining rounds, the sellers picks the strategy that maximizes the empirical mean of the observed rewards. For each seller, we set T = 200 and \u03b5 = 0.1. Exponential-weight Algorithm for Exploration and Exploitation (Exp3) [5, 6]: We use the definition of the algorithm from [6]. Let \u03b3 \u2208(0, 1] be a real number and initialize wi(1) = 1 for i = 1, . . . ,K + 1 to be the initial weights of the possible prices4. In each round t, \u2022 For i = 1, . . . ,K + 1, let \u03c0i(t) = (1 \u2212\u03b3) wi(t) \u00cdK+1 j=1 wj(t) + \u03b3 K+1, where wi(t) is the weight of price pi in round t. \u2022 Select a price pj(t) according to the probability distribution defined by \u03c01(t), . . . , \u03c0K+1(t). \u2022 Receive payoff uj(t) \u2208[0, 1]. 4For ease of notation, we drop the subscript referring to a specific seller, as there is no ambiguity. \u2022 For \u2113= 1, . . . ,K + 1, let \u02c6 u\u2113(t) = ( u\u2113(t)/\u03c0\u2113(t), if \u2113= j 0, otherwise and w\u2113(t + 1) = w\u2113(t)e\u03b3 \u00b7 \u02c6 u\u2113(t)/(K+1). We remark here that since the payoff of each seller in some round t actually takes values in [\u22121, 1], we scale the payoff to [0, 1] by applying the transformation f (u) = (u + 1)/2 to any payoff u. Upper Confidence Bound Algorithm (UCB1) [2, 4]: For each price pj \u2208[0, 1/K, 2/K, . . . , 1], initialize xj(1) = 0. At the end of each round t, update xj(t) as: xj(t) = ( xj(t \u22121)/t + uj(t)/t, if j was chosen in this round t xj(t \u22121), otherwise For any round t \u2208{0, . . . ,K}, the seller chooses a price pj that has not been used before in any of the previous rounds (breaking ties arbitrarily). For any round t \u2265K + 1, the seller chooses the price pj with the maximum weighted value xj, i.e, pj(t) \u2208arg max j \u2208{0,1/K,...,1} xj(t) + log2 t \u00cdt \u03c4 =1 Ij\u03c4 , where Ij\u03c4 is the indicator function, i.e. Ij\u03c4 = ( 1, if pj was chosen in round \u03c4 0, otherwise. \u03b5-Greedy and \u03b5-First are simple strategies that maintain a clear distinction between exploration and exploitation and belong to the class of semi-uniform strategies. Exp3 is the most widely used bandit version of perhaps the most popular no-regret algorithm for the full information setting, the Hedge (or Multiplicative Weight updates) algorithm [17] and works in the adversarial bandit feedback model [6], where no distributional assumptions are being made about the nature of the rewards. UCB1, as the name suggests, maintains a certain level of optimism towards less frequently played actions (given by the second part of the sum) and together with this, it uses the empirical mean of observed actions so far to choose the action in the next round. The algorithm is best suited in scenarios where the rewards do follow some distribution which is however unknown to the seller. For a more detailed exposition of all these different algorithms, [9] provides a concise survey. The point made here is that these choices are quite sensible as they (i) constitute choices that a relatively sophisticated seller, perhaps with a research team at its disposal could make, (ii) can model sellers with different degrees of sophistication or pricing philosophies and (iii) are consistent with the recent literature on algorithmic mechanism design, in terms of modeling agent rationality in complex dynamic environments. 3 ALLOCATION ALGORITHMS In this section, we will briefly describe the algorithms that we will be comparing IA(GRU) against two natural heuristics similar to those employed by platforms for the impression allocation problem, as well as the DDPG algorithm of Lillicrap et al. [27]. \fHeuristic Allocation Algorithms As the strategies of the sellers are unknown to the platform, and the only information available is the sellers\u2019 historical records, the platform can only use that information for the allocation. Note that these heuristics do not take the rationality of the sellers into account, when deciding on the allocation of impressions. The first algorithm is a simple greedy algorithm, which allocates the impressions proportionally to the revenue contribution. Greedy Myopic Algorithm: At round 0, the algorithm allocates a 1/m-fraction of the buyer impression to each seller. At any other round \u03c4 + 1 (for \u03c4 \u22650), the algorithm allocates a fraction of \u2113i\u03c4 /\u00cdm j=1 \u2113j\u03c4 of the buyer impression to each seller, i.e. proportionally to the contribution of each seller to the total revenue of the last round. The second algorithm is an algorithm for the contextual multi-arm bandit problem, proposed by [26], based on the principles of the family of upper confidence bound algorithms (UCB1 is an algorithm in this family). The algorithm is among the state of the art solutions for recommender systems [9] and is an example of contextual bandit approaches, which are widely applied to such settings [3, 8, 25, 26]. To prevent any confusion, we clarify here that while we also used bandit algorithms for the seller rationality models, the approach here is fundamentally different as the Linear UCB Algorithm is used for the allocation of impressions not the choice of prices and the arms in this case are the different sellers. Linear UCB Algorithm [26]: We implement the algorithm as described in [26] in the interest of space, we do not provide the definition of the algorithm, but refer the reader to Algorithm 1 in [26]. We model each seller as an arm and set hit as the feature of each arm i in each round t. The parameter \u03b1 is set to 1. Deep Deterministic Policy Gradient Here, we briefly describe the DDPG algorithm of [27], which we we draw inspiration from in order to design our impression allocation algorithm. Before describing the algorithm, we briefly mention the main ingredients of its predecessor, the DPG algorithm of Silver et al. [37]. Deterministic Policy Gradient: The shortcoming of DQN [31] is that while it can handle continuous states, it can not handle continuous actions or high-dimensional action spaces. Although stochastic actor-critic algorithms could handle continuous actions, they are hard to converge in high dimensional action spaces. The DPG algorithm [37] aims to train a deterministic policy \u00b5\u03b8 : S \u2192A with parameter vector \u03b8 \u2208Rn. This algorithm consists of two components: an actor, which adjusts the parameters \u03b8 of the deterministic policy \u00b5\u03b8 (s) by stochastic gradient ascent of the gradient of the discounted sum of rewards, and the critic, which approximates the action-value function. Deep Deterministic Policy Gradient: Directly training neural networks for the actor and the critic of the DPG algorithm fails to achieve convergence; the main reason is the high degree of temporal correlation which introduces high variance in the approximation of the Q-function by the critic. For this reason, the DDPG algorithm uses a technique known as experience replay, according to which the experiences of the agent at each time step are stored in a replay buffer and then a mini-batch is sampled uniformly at random from this set for learning, to eliminate the temporal correlation. The other modification is the employment of target networks for the regularization of the learning algorithm. The target network is used to update the values of \u00b5 and Q at a slower rate instead of updating by the gradient network; the prediction yt will be relatively fixed and violent jitter at the beginning of training is absorbed by the target network. A similar idea appears in [42] with the form of double Q-value learning. 4 THE IMPRESSION ALLOCATION (GRU) ALGORITHM In this section, we present our main deep reinforcement learning algorithm, termed IA(GRU) (\u201cIA\u201d stands for \u201cimpression allocation\u201d and \u201cGRU\u201d stands for \u201cgated recurrent unit\u201d) which is in the center of our framework for impression allocations in e-commerce platforms and is based on the ideas of the DDPG algorithm. Before we present the algorithm, we highlight why simply applying DDPG to our problem can not work. Shortcomings of DDPG: First of all, while DDPG is designed for settings with continuous and often high-dimensional action spaces, the blow-up in the number of actions in our problem is very sharp as the number of sellers increases; this is because the action space is the set of all feasible allocations, which increases very rapidly with the number of sellers. As we will show in Section 5, the direct application of the algorithm fails to converge even for a moderately small number of sellers. The second problem comes from the inability of DDPG to handle variability on the set of sellers. Since the algorithm uses a two-layer fully connected network, the position of each seller plays a fundamental role; each seller is treated as a different entity according to that position. As we show in Section 5, if the costs of sellers at each round are randomly selected, the performance of the DDPG algorithm deteriorates rapidly. The settings in real-life e-commerce platforms however are quite dynamic, with sellers arriving and leaving or their costs varying over time, and for an allocation algorithm to be applicable, it should be able to handle such variability. We expect that each seller\u2019s features are only affected by its historical records, not some \u201cidentity\u201d designated by the allocation algorithm; we refer to this highly desirable property as \"permutation invariance\". Based on time-serial techniques, our algorithm uses Recurrent Neural Networks at the dimension of the sellers and achieves the property. The IA(GRU) algorithm: Next, we explain the design of our algorithm, but we postpone some implementation details for Section 5. At a high level, the algorithm uses the framework of DDPG with different network structures and different inputs of networks. It maintains a sub-actor network and a sub-critic network for each \fFigure 1: The framework of the actor network of the IA(GRU) algorithm. seller and employs input preprocessing at each training step, to ensure permutation invariance. Input Preprocessing: In each step of training, with a state tensor of shape (T,m, 4), we firstly utilize a background network to calculate a public vector containing information of all sellers: it transforms the state tensor to a (T,m \u00d74) tensor and performs RNN operations on the axis of rounds. At this step, it applies a permutation transformation, i.e. a technique for maintaining permutation invariance. Specifically, it first orders the sellers according to a certain metric, such as the weighted average of their past generated revenue and then inputs the (state, action) pair following this order to obtain the public vector (pv). On the other hand, for each seller i, it applies a similar RNN operation on its history, resulting in an individual temporal feature called (fi). Combining those two features, we obtain a feature vector (pv, fi) that we will use as input for the sellers\u2019 sub-actor and sub-critic networks. Actor network: For each seller, the input to the sub-actor network is (pv, fi) and the output is a score. This algorithm uses a softmax function over the outputs of all sub-actor networks in order to choose an action. The structure of the policy which is shown in Figure 1 ensures that the policy space is much smaller than that of DDPG as the space of inputs of all sub-actor networks is restricted, and allows for easier convergence, as we will show in Section 5. Critic network: For the critic, we make use of a domain-specific property, namely that the immediate reward of each round is the sum of revenues of all sellers and the record of each seller has the same space. Each sub-critic network inputs the expected fraction of buyer impression the seller gets (the sub-action) and (pv, fi) (the sub-state) as input and outputs the Q-value of the corresponding seller, i.e, the expected discounted sum of revenues from the substate following the policy. Then, it sums up the estimated Q-value of all sub-critic networks to output the final estimated Q-value, with the assumption that the strategy of each seller is independent of the records of other sellers, which is the case in all of our rationality models. The framework of the critic network is similar to Figure 1. 5 EXPERIMENTAL EVALUATION In this section, we present the evaluation of our algorithms in terms of convergence time and revenue performance against several benchmarks, namely the direct application of the DDPG algorithm (with a fully connected network) and the heuristic allocation algorithms that we defined in Section 3. We use Tensorflow and Keras as the engine for the deep learning, combining the idea of DDPG and the techniques mentioned in Section 4, to train the neural network. Designed experiments: First, we will compare IA(GRU) and DDPG in terms of their convergence properties in the training phase and show that the former converges while the latter does not. Next, we will compare the four different algorithms (Greedy Myopic, Linear UCB, DDPG and IA(GRU)) in terms of the generated revenue for two different settings, a setting with fixed sellers and a setting with variable sellers. The difference is that in the former case, we sample the costs ci once in the beginning whereas in the latter case, the cost ci of each seller is sampled again in each round. This can either model the fact that the production costs of sellers may vary based on unforeseeable factors or simply that sellers of different capabilities may enter the market in each round. For each one of these two settings, we will compare the four algorithms for each one of the four different rationality models (\u03f5-Greedy, \u03f5-First, UCB1 and Exp3) separately as well as in a combined manner, by assuming a mixed pool of sellers, each of which may adopt a different rationality model from the ones above. The latter comparison is meant to capture cases where the population of sellers is heterogeneous and may consist of more capable sellers that employ their R&D resources to come up with more sophisticated approaches (such as UCB1 or Exp3) but also on more basic sellers that employ simpler strategies (such as \u03f5-Greedy). Another interpretation is that the distinction is not necessarily in terms of sophistication, but could also be due to different market research, goals, or general business strategies, which may lead to different decisions in terms of which strategy to adopt. Our experiments are run for 200 sellers, a case which already captures a lot of scenarios of interest in real e-commerce platforms. A straightforward application of the reinforcement learning algorithms for much larger numbers of sellers is problematic however, as the action space of the MDP increases significantly, which has drastic effects on their running time. To ensure scalability, we employ a very natural heuristic, where we divide the impression allocation problem into sub-problems and then solve each one of those in parallel. We show at the end of the section that this \u201cscale-and-solve\u201d version of IA(GRU) clearly outperforms the other algorithms for large instances consisting of as many as 10.000 sellers. Experimental Setup: In the implementation of DDPG, the actor network uses two full connected layers, a rectified linear unit (ReLu) \f(a) Rewards of DDPG in training (b) Rewards of IA(GRU) in training Figure 2: Rewards of DDPG and IA(GRU) in training for rational sellers. as the activation function, and outputs the action by a softmax function. The critic network inputs a (state,action) pair and outputs the estimation of the Q-value using similar structure. The algorithm IA(GRU) uses the same structure, i.e. the fully connected network in the sub-actor and sub-critic networks, and uses a Recurrent Neural Network with gate recurrent units (GRU) in cyclic layers to obtain the inputs of these networks. For the experiments we set T = 1, i.e, the record of all items of the last round is viewed as the state.5 We employ heuristic algorithms such as the Greedy Myopic Algorithm for exploration, i.e. we add these samples to the replay buffer before training. Experimental Parameters: We use 1000 episodes for both training and testing, and there are 1000 steps in each episode. The valuation of the buyer in each round is drawn from the standard uniform distribution U (0, 1) and the costs of sellers follow a Gaussian distribution with mean 1/2 and variance 1/2. The size of the replay buffer is 105, the discount factor \u03b3 is 0.99, and the rate of update of the target network is 10\u22123. The actor network and the critic network are trained via the Adam algorithm, a gradient descent algorithm presented in [24], and the learning rates of these two networks are 10\u22124. Following the same idea as in [27], we add Gaussian noise to the action outputted by the actor network, with the mean of the noise decaying with the number of episodes in the exploration. Convergence of DDPG and IA(GRU) First, to show the difference in the convergence properties of DDPG and IA(GRU), we train the algorithms for 200 sellers using the \u03f5greedy strategy as the rationality model with variable costs for the sellers. Figure 2 shows the comparison between the rewards of the algorithms and Figure 3 shows the comparison in terms of the training loss with the number of steps. The gray band shows the variance of the vector of rewards near each step. From the figures, we see that DDPG does not converge, while IA(GRU) converges, as the training loss of the algorithm decreases with the number of steps. The convergence properties for the other rationality models are very similar. 5We found out that training our algorithms for larger values of T does not help to improve the performance. (a) Loss of DDPG in training (b) Loss of IA(GRU) in training Figure 3: Loss of DDPG and IA(GRU) in training for rational sellers. Performance Comparison In this subsection, we present the revenue guarantees of IA(GRU) in the setting with 200 sellers and how it fairs against the heuristics and DDPG, for either each rationality model separately, or for a heterogeneous pool of sellers, with a 1/4-fraction of the sellers following each strategy. As explained in the previous page, we consider both the case of fixed sellers and variable sellers. Performance Comparison for Fixed Sellers: We show the performance of DDPG, IA(GRU), Greedy Myopic and Linear UCB on sellers using \u2022 the \u03f5-Greedy strategy (Figure 4), \u2022 the \u03f5-First strategy (Figure 5), \u2022 the UCB1 strategy (Figure 6), \u2022 the Exp3 strategy (Figure 7). We also show the performance of the four different algorithms in the case of a heterogeneous population of sellers in Figure 8. Every point of the figures shows the reward at the corresponding step. We can conclude that the IA(GRU) algorithm is clearly better than the other algorithms in terms of the average reward on all rationality models. We also note that DPPG does not converge with 200 sellers and this is the reason for its poor performance. Performance Comparison for Variable Sellers: We show the performance of DDPG, IA(GRU), Greedy Myopic and Linear UCB on sellers using \u2022 the \u03f5-Greedy strategy (Figure 9), \u2022 the \u03f5-First strategy (Figure 10), \u2022 the UCB1 strategy (Figure 11), \u2022 the Exp3 strategy (Figure 12). We also show the performance of the four different algorithms in the case of a heterogeneous population of sellers in Figure 13. Again here, we can conclude that the IA(GRU) algorithm clearly outperforms all the other algorithms in terms of the average reward on all rationality models. Also, IA(GRU) fairs better in terms of stability, as the other algorithms perform worse in the setting with variable sellers, compared to the setting with fixed sellers. Scalability In this subsection, we present the revenue guarantees of IA(GRU) in the setting with 10000 fixed sellers and how it fairs against the \fFigure 4: Rewards for fixed sellers and \u03f5-Greedy strategies. Figure 5: Rewards for fixed sellers and \u03f5-First strategies. Figure 6: Rewards for fixed sellers and UCB1 strategies. heuristics and DDPG to show the scalability properties of IA(GRU) with the number of sellers. For IA(GRU) and DDPG, we will employ a simple \u201cscale-and-solve\u201d variant, since applying either of them directly to the pool of 10.000 sellers is prohibitive in terms of their running time. We design 50 allocation sub-problems, consisting of 200 sellers each, and divide the total number of impressions in 50 sets of equal size, reserved for each sub-problem. We run IA(GRU) and DDPG algorithms in parallel for each sub-problem, which is Figure 7: Rewards for fixed sellers and Exp3 strategies. Figure 8: Rewards for fixed sellers and heterogeneous strategies. Figure 9: Rewards for variable sellers and \u03f5-Greedy strategies. feasible in reasonable time. For the heuristics, we run the algorithms directly on the large population of 10.000 sellers. The results for the case of \u03f5-Greedy seller strategies are show in Figure 14 (the results for other strategies are similar). We can see that even though we are applying a heuristic version, the performance of IA(GRU) is \fFigure 10: Rewards for variable sellers and \u03f5-First strategies. Figure 11: Rewards for variable sellers and UCB1 strategies. Figure 12: Rewards for variable sellers and Exp3 strategies. still clearly superior to all the other algorithms, which attests to the algorithm being employable in larger-case problems as well. 6"
+                }
+            ],
+            "Kun Gai": [
+                {
+                    "url": "http://arxiv.org/abs/1704.05194v1",
+                    "title": "Learning Piece-wise Linear Models from Large Scale Data for Ad Click Prediction",
+                    "abstract": "CTR prediction in real-world business is a difficult machine learning problem\nwith large scale nonlinear sparse data. In this paper, we introduce an\nindustrial strength solution with model named Large Scale Piece-wise Linear\nModel (LS-PLM). We formulate the learning problem with $L_1$ and $L_{2,1}$\nregularizers, leading to a non-convex and non-smooth optimization problem.\nThen, we propose a novel algorithm to solve it efficiently, based on\ndirectional derivatives and quasi-Newton method. In addition, we design a\ndistributed system which can run on hundreds of machines parallel and provides\nus with the industrial scalability. LS-PLM model can capture nonlinear patterns\nfrom massive sparse data, saving us from heavy feature engineering jobs. Since\n2012, LS-PLM has become the main CTR prediction model in Alibaba's online\ndisplay advertising system, serving hundreds of millions users every day.",
+                    "authors": "Kun Gai, Xiaoqiang Zhu, Han Li, Kai Liu, Zhe Wang",
+                    "published": "2017-04-18",
+                    "updated": "2017-04-18",
+                    "primary_cat": "stat.ML",
+                    "cats": [
+                        "stat.ML",
+                        "cs.LG"
+                    ],
+                    "main_content": "Introduction Click-through rate (CTR) prediction is a core problem in the multi-billion dollar online advertising industry. To improve the accuracy of CTR prediction, more and more data are involved, making CTR prediction a large scale learning problem, with massive samples and high dimension features. Traditional solution is to apply a linear logistic regression (LR) model, trained in a parallel manner (Brendan et al. 2013, Andrew & Gao 2007). LR model with L1 regularization can generate sparse solution, making it fast for online prediction. Unfortunately, CTR prediction problem is a highly nonlinear problem. In particular, user-click generation involves many complex factors, like ad quality, context information, user interests, and complex interactions of these factors. To help LR model catch the nonlinearity, feature engineering technique is explored, which is both time and humanity consuming. Another direction, is to capture the nonlinearity with well-designed models. Facebook (He et al. 2014) uses a hybrid model which combines decision trees with logistic regression. Decision tree plays a nonlinear feature transformation role, whose output is fed to LR model. However, tree-based method is not suitable for very sparse and high dimensional data (Safavian S. R. & Landgrebe D. 1990). (Rendle S. 2010) introduces Factorization Machines(FM), which involves interactions among features using 2nd order functions (or using other given-number-order functions). However, FM can not \ufb01t all general nonlinear patterns in data (like other higher order patterns). 1 arXiv:1704.05194v1  [stat.ML]  18 Apr 2017 \fIn this paper, we present a piece-wise linear model and its training algorithm for large scale data. We name it Large Scale Piecewise Linear Model (LS-PLM). LS-PLM follows the divide-and-conquer strategy, that is, \ufb01rst divides the feature space into several local regions, then \ufb01ts a linear model in each region, resulting in the output with combinations of weighted linear predictions. Note that, these two steps are learned simultaneously in a supervised manner, aiming to minimize the prediction loss. LS-PLM is superior for web-scale data mining in three aspects: \u2022 Nonlinearity. With enough divided regions, LS-PLM can \ufb01t any complex nonlinear function. \u2022 Scalability. Similar to LR model, LS-PLM is scalable both to massive samples and high dimensional features. We design a distributed system which can train the model on hundreds of machines parallel. In our online product systems, dozens of LS-PLM models with tens of million parameters are trained and deployed everyday. \u2022 Sparsity. As pointed in (Brendan et al. 2013), model sparsity is a practical issue for online serving in industrial setting. We show LS-PLM with L1 and L2,1 regularizer can achieve good sparsity. The learning of LS-PLM with sparsity regularizer can be transformed to be a non-convex and nondi\ufb00erential optimization problem, which is di\ufb03cult to be solved. We propose an e\ufb03cient optimization method for such problems, based on directional derivatives and quasi-Newton method. Due to the ability of capturing nonlinear patterns and scalability to massive data, LS-PLMs have become main CTR prediction models in the online display advertising system in alibaba, serving hundreds of millions users since 2012 early. It is also applied in recommendation systems, search engines and other product systems. The paper is structured as follows. In Section 2, we present LS-PLM model in detail, including formulation, regularization and optimization issues. In Section 3 we introduce our parallel implementation structure. in Section 4, we evaluate the model carefully and demonstrate the advantage of LS-PLM compared with LR. Finally in Section 5, we close with conclusions. Figure 1: A demo illustration of LS-PLM model. Figure A is the demo dataset. It is a binary classi\ufb01cation problem, with red points belong to positive class and blue points belong to negative class. Figure B shows the classi\ufb01cation result using LR model. Figure C shows the classi\ufb01cation result using LS-PLM model. It\u2019s clear that LS-PLM can capture the nonlinear distribution of data. 2 Method We focus on the large scale CTR prediction application. It is a binary classi\ufb01cation problems, with dataset {xt, yt}|n t=1. yt \u2208{0, 1} and xt \u2208Rd is usually high dimensional and sparse. 2.1 Formulation To model the nonlinearity of massive scale data, we employ a divide-and-conquer strategy, similar with (Jordan & Jacobs 1994). We divide the whole feature space into some local regions. For each region we 2 \femploy an individual generalized linear-classi\ufb01cation model. In this way, we tackle the nonlinearity with a piece-wise linear model. We give our model as follows: p(y = 1|x) = g \u0010 m X j=1 \u03c3(uT j x)\u03b7(wT j x) \u0011 (1) Here \u0398 = {u1, \u00b7 \u00b7 \u00b7 , um, w1, \u00b7 \u00b7 \u00b7 , wm} \u2208Rd\u00d72m denote the model parameters. {u1, \u00b7 \u00b7 \u00b7 , um} is the parameters for dividing function \u03c3(\u00b7), and {w1, \u00b7 \u00b7 \u00b7 , wm} for \ufb01tting function \u03b7(\u00b7). Given instance x, our predicating model p(y|x) consists of two parts: the \ufb01rst part \u03c3(uT j x) divides feature space into m (hyper-parameter) di\ufb00erent regions, the second part \u03b7(wT j x) gives prediction in each region. Function g(\u00b7) ensures our model to satisfy the de\ufb01nition of probability function. Special Case. Take softmax ( Kivinen & Warmuth 1998) as dividing function \u03c3(x) and sigmoid (Hilbe 2009) as \ufb01tting function \u03b7(x) and g(x) = x, we get a speci\ufb01c formulation: p(y = 1|x) = m X i=1 exp(uT i x) Pm j=1 exp(uT j x) \u00b7 1 1 + exp (\u2212wT i x) (2) In this case, our mixture model can be seen as a FOE model (Jordan & Jacobs 1994, Wang & Puterman 1998) as follows: p(y = 1|x) = m X i=1 p(z = i|x)p(y|z = i, x) (3) Eq.(2) is the most common used formulation in our real applications. In the reminder of the paper, without special declaration, we take Eq.(2) as our prediction model. Figure 1 illustrates the model compared with LR in a demo dataset, which shows clearly LS-PLM can capture the nonlinear pattern of data. The objective function of LS-PLM model is formalized as Eq.(4): arg min \u0398f(\u0398) = loss(\u0398) + \u03bb\u2225\u0398\u22252,1 + \u03b2\u2225\u0398\u22251 (4) loss(\u0398)=\u2212 n X t=1 h yt log (p(yt =1|xt, \u0398)) + (1 \u2212yt) log(p(yt =0|xt, \u0398)) i (5) Here loss(\u0398) de\ufb01ned in Eq.(5) is the neg-likelihood loss function and \u2225\u03982,1\u2225and \u2225\u03981\u2225are two regularization terms providing di\ufb00erent properties. First, L2,1 regularization (\u2225\u0398\u22252,1 = Pd i=1 qP2m j=1 \u03b82 ij) is employed for feature selection. As in our model, each dimension of feature is associated with 2m parameters. L2,1 regularization are expected to push all the 2m parameters of one dimension of feature to be zero, that is, to suppress those less important features. Second, L1 regularization (\u2225\u0398\u22251 = P ij |\u03b8ij|) is employed for sparsity. Except with the feature selection property, L1 regularization can also force those parameters of left features to be zero as much as possible, which can help improve the interpretation ability as well as generalization performance of the model. However, both L1 norm and L2,1 norm are non-smooth functions. This causes the objective function of Eq.(4) to be non-convex and non-smooth, making it di\ufb03cult to employ those traditional gradient-descent optimization methods (Andrew & Gao 2007, Zhang 2004, Bertsekas 2003) or EM method (Wang & Puterman 1998). Note that, while (Wang & Puterman 1998) gives the same mixture model formulation as Eq.(3), our model is more general for employing di\ufb00erent kinds of prediction functions. Besides, we propose a di\ufb00erent objective function for large scale industry data, taking the feature sparsity into consideration explicitly. This is crucial for real-world applications, as prediction speed and memory usage are two key indicators for online model serving. Furthermore, we give a more e\ufb03cient optimization method to solve the large-scale non-convex problem, which is described in the following section. 3 \f2.2 Optimization Before we present our optimization method, we establish some notations and de\ufb01nitions that will be used in the reminder of the paper. Let \u2202+ ijf(\u0398) denote the right partial derivative of f at \u0398 with respect to \u0398ij: \u2202+ ijf(\u0398) = lim \u03b1\u21930 f(\u0398 + \u03b1eij) \u2212f(\u0398) \u03b1 (6) where eij is the ijth standard basis vector. The directional derivative of f as \u0398 in direction d is denoted as f \u2032(\u0398; d), which is de\ufb01ned as: f \u2032(\u0398; d) = lim \u03b1\u21930 f(\u0398 + \u03b1d) \u2212f(\u0398) \u03b1 (7) A vector d is regarded as a descent direction if f \u2032(\u0398; d) < 0. sign(\u00b7) is the sign function takes value {\u22121, 0, 1}. The projection function \u03c0ij(\u0398; \u2126) = ( \u0398ij , sign(\u0398ij) = sign(\u2126ij) 0 , otherwise (8) means projecting \u0398 onto the orthant de\ufb01ned by \u2126. 2.2.1 Choose descent direction As discussed above, our objective function for large scale CTR prediction problem is both non-convex and non-smooth. Here we propose a general and e\ufb03cient optimization method to solve such kind of non-convex problems. Since the negative-gradients of our objective function do not exists for all \u0398, we take the direction d which minimizes the directional derivative of f with \u0398 as a replace. The directional derivative f \u2032(\u0398; d) exists for any \u0398 and direction d, whic is declared as Lemma 1. Lemma 1. When an objective function f(\u0398) is composed by a smooth loss function with L1 and L2,1 norm, for example the objective function given in Eq. (4), the directional derivative f \u2032(\u0398; d) exists for any \u0398 and direction d. We leave the proof in Appendix A. Since the directional derivative f \u2032(\u0398; d) always exists, we choose the direction as the descent direction which minimizes the directional derivative f \u2032(\u0398; d) when the negative gradient of f(\u0398) does not exist. The following proposition 2 explicitly gives the direction. Proposition 2. Given a smooth loss function loss(\u0398) and an objective function f(\u0398) = loss(\u0398)+\u03bb\u2225\u0398\u22252,1 + \u03b2\u2225\u0398\u22251, the bounded direction d which minimizes the directional derivative f \u2032(\u0398; d) is denoted as follows: dij = \uf8f1 \uf8f4 \uf8f2 \uf8f4 \uf8f3 s \u2212\u03b2sign(\u0398ij), \u0398ij \u0338= 0 max{|s| \u2212\u03b2, 0}sign(s), \u0398ij = 0, \u2225\u0398i\u00b7\u22252,1 \u0338= 0 max{\u2225v\u22252,1\u2212\u03bb,0} \u2225v\u22252,1 v, \u2225\u0398i\u00b7\u22252,1 = 0, (9) where s = \u2212\u2207loss(\u0398)ij \u2212\u03bb \u0398ij \u2225\u0398i\u00b7\u22252,1 and v = max{| \u2212\u2207loss(\u0398)ij| \u2212\u03b2, 0}sign(\u2212\u2207loss(\u0398)ij). More details about the proof can be found in Appendix B. According to the proof, we can see that the negative pseudo-gradient de\ufb01ned in Gao\u2019s work (Andrew & Gao 2007) is a special case of our descent direction. Our proposed method is more general to \ufb01nd the descent direction for those non-smooth and non-convex objective functions. Based on the direction dk in Eq.(9), we update the model parameters along a descent direction calculated by limited-memory quasi-newton method (LBFGS) (Wang & Puterman 1998), which approximates the inverse Hessian matrix of Eq.(4) on the given orthant. Motivated by the OWLQN method (Andrew & 4 \fAlgorithm 1 Optimize problem Eq.(4) Input:Choose initial point \u0398(0) S \u2190{}, Y \u2190{} for k = 0 to MaxIters do 1. Compute d(k) with Eq. (9). 2. Compute pk with Eq. (11) using S and Y . 3. Find \u0398(k+1) with constrained line search (12). 4. If termination condition satis\ufb01ed then stop and return \u0398(k+1) End if 5. Update S with s(k) = \u0398(k) \u2212\u0398(k\u22121) 6. Update Y with y(k) = \u2212d(k) \u2212(\u2212d(k\u22121)) end for Gao 2007), we also restrict the signs of model parameters not changing in each iteration. Given the chosen direction dk and the old \u0398(k), we constrain the orthant of current iteration as follows: \u03be(k) ij = ( sign(\u0398(k) ij ), \u0398(k) ij \u0338= 0 sign(d(k) ij ), \u0398(k) ij = 0 . (10) When \u0398(k) ij \u0338= 0, the new \u0398ij would not change sign in current iteration. When \u0398(k) ij = 0, we choose the orthant decided by the selected direction d(k) ij for the new \u0398(k) ij . 2.2.2 Update direction constraint and line search Given the descent direction dk, we approximate the inverse-Hessian matrix Hk using LBFGS method with a sequence of y(k), s(k). Then the \ufb01nal update direction is Hkd(k). Here we give two tricks to adjust the update direction. First, we constrain the update direction in the orthant with respect to d(k). Second, as our objective function is non-convex, we cannot guarantee that Hk is positive-de\ufb01nite. We use y(k)T s(k) > 0 as a condition to ensure Hk is a positive-de\ufb01nite matrix. If y(k)T s(k) \u22640, we switch to d(k) as the update direction. The \ufb01nal update direction pk is de\ufb01ned as follows: pk = ( \u03c0(Hkd(k); d(k)), y(k)T s(k) > 0 d(k), otherwise (11) Given the update direction, we use backtracking line search to \ufb01nd the proper step size \u03b1. Same as OWLQN, we project the new \u0398(k+1) onto the given orthant decided by the Eq. (10). \u0398(k+1) = \u03c0(\u0398(k) + \u03b1pk; \u03be(k)) (12) 2.3 Algorithm A pseudo-code description of optimization is given in Algorithm 1. In fact, only a few steps of the standard LBFGS algorithm need to change. These modi\ufb01cations are: 1. The direction d(k) which minimizes the direction derivative of the non-convex objective is used in replace of negative gradient. 5 \f2. The update direction is constrained to the given orthant de\ufb01ned by the chosen direction d(k). Switch to d(k) when the Hk is not positive-de\ufb01nite. 3. During the line search, each search point is projected onto the orthant of the previous point. 3 Implementation In this section, we \ufb01rst provide our parallel implementation of LS-PLM model for large-scale data, then introduce an important trick which helps to accelerate the training procedue greatly. Figure 2: The architecture of parallel implementation. Figure A illustrates the physical distributed topology. It\u2019s a variant of parameter server, where each computation node runs with both a server and a worker, aiming to maximize the utility of computation power as well as memory usuage. Figure B illustrates the parameter server structure in model-parallelism and data-parallelism manner. 3.1 Parallel implementation To apply Algorithm 1 in large-scale settings, we implement it with a distributed learning framework, as illustrated in Figure 2. It\u2019s a variant of parameter server. In our implementation, each computation node runs with both a server node and a worker node, aiming to \u2022 Maximize the utility of CPU\u2019s computation power. In traditional parameter server setting, server nodes work as a distributed KV storer with interfaces of push and pull operations, which are low computation costly. Running with worker nodes can make full use of the computation power. \u2022 Maximize the utility of memory. Machines today usually have big memory, for example 128GB. Running on the same computation node, server node and worker node can share and utilize the big memory better. In brief, there are two roles in the framework. The \ufb01rst role is the work node. Each node stores a part of training data and a local model, which only saves the model parameters used for the local training data. The second role is the server node. Each node stores a part of global model, which is mutually-exclusive. In each iteration, all of the worker nodes \ufb01rst calculate the loss and the descent direction with local model and local data in parallel(data parallelism). Then server nodes aggregate the loss and the direction d(k) as 6 \fwell as the corresponding entries of \u0398 needed to calculate the revised gradient (model parallelism). After \ufb01nishing calculating the steepest descent direction in Step 1, workers synchronize the corresponding entries of \u0398, and then, perform Step 2\u20136 locally. 3.2 Common Feature Trick Figure 3: Common feature pattern in display advertising. Usually in each page view, a user will see several di\ufb00erent ads at the same time. In this situation, user features can be shared across these samples. In addition to the general-purpose parallel implementation, we also optimized the implementation in online advertising context. Training samples in CTR prediction tasks usually have similar common feature pattern. Take display advertising as an example, as illustrated in Figure 3, during each page view, a user will see several di\ufb00erent ads at the same time. For example, user U1 in Figure 3 sees three ads in one visit session, thus generates three samples. In this situation, features of user U1 can be shared across these three samples. These features include user pro\ufb01les (sex, age, etc.) and user behavior histories during visits of Alibabas e-commerce websites, for example, his/her shopping item IDs, preferred brands or favorite shop IDs. Remember the model de\ufb01ned in Eq. 2, most computation cost focus on \u00b5T i x and wT i x. By employing the common feature trick, we can split the calculation into common and non-common parts and rewrite them as follows: \u00b5T i x = \u00b5T i,cxc + \u00b5T i,ncxnc (13) wT i x = wT i,cxc + wT i,ncxnc Hence, for the common feature part, we need just calculate once and then index the result, which will be utilized by the following samples. Speci\ufb01cally, we optimize the parallel implementation with common features trick in the following three aspects: \u2022 Group training samples with common features and make sure these samples are stored in the same worker. \u2022 Save memory by storing common features shared by multiple samples only once. \u2022 Speed up iteration by updating loss and gradient w.r.t. common features only once. Due to the common feature pattern of our production data, employing the common feature trick improves the performance of training procedure greatly, which will be shown in the following section 4.3. 4 Experiments In this session, we evaluate the performance of LS-PLM. Our datasets are generated from Alibaba\u2019s mobile display advertising product system. As shown in Table 1, we collect seven datasets in continuous sequential 7 \fTable 1: Alibaba\u2019s mobile display advertising CTR prediction datasets Dataset #features #samples (training/validation/testing) 1 3.04 \u00d7 106 1.34/0.25/0.26 \u00d7 109 2 3.27 \u00d7 106 1.44/0.26/0.26 \u00d7 109 3 3.49 \u00d7 106 1.56/0.26/0.25 \u00d7 109 4 3.67 \u00d7 106 1.62/0.25/0.26 \u00d7 109 5 3.82 \u00d7 106 1.69/0.26/0.26 \u00d7 109 6 3.95 \u00d7 106 1.74/0.26/0.26 \u00d7 109 7 4.07 \u00d7 106 1.78/0.26/0.26 \u00d7 109 periods, aiming to evaluate the consist performance of the proposed model, which is important for online product serving. In each dataset, training/validation/testing samples are disjointly collected from di\ufb00erent days, with proportion about 7:1:1. AUC (Fawcett 2006) metric is used to evaluate the model performance. 4.1 E\ufb00ectiveness of division number LS-PLM is a piece-wise linear model, with division number m controlling the model capacity. We evaluate the division e\ufb00ectiveness on model\u2019s performance. It is executed on dataset 1 and results are shown in Figure 4. Generally speaking, larger m means more parameters and thus leads to larger model capacity. But the training cost will also increase, both time and memory. Hence, in real applications we have to balance the model performance with the training cost. Figure 4: Model performance with di\ufb00erent divisions. Figure 4 shows the training and testing AUC with di\ufb00erent division number m. We try m = 6, 12, 24, 36, the testing AUC for m = 12 is markedly better than m = 6, and improvement for m = 24, 36 is relatively gentle. Thus in all the following experiments , the parameter m is set as 12 for LS-PLM model. 4.2 E\ufb00ectiveness of regularization As stated in Session 2, in order to keep our model simpler and more generalized, we prefer to constrain the model parameters sparse by both L1 and L2,1 norms. Here we evaluate the strength of both the regularization terms. Table 2 gives the results. As expected, both L1 and L2,1 norms can push our model to be sparse. Model trained with L2,1 norm has only 9.4% non-zero parameters left and 18.7% features are kept back. While in L1 norm case, there are only 1.9% non-zero parameters left. Combining them together, we get the sparsest 8 \fTable 2: Regularization e\ufb00ects on model sparsity and performance \u03b2/\u03bb(L1/L2,1) #features #non-zero parameters testing auc 0/0 3.04 \u00d7 106 7.30 \u00d7 107 0.6489 0/1 5.68 \u00d7 105 6.64 \u00d7 106 0.6570 1/0 3.87 \u00d7 105 1.33 \u00d7 106 0.6617 1/1 2.55 \u00d7 105 1.15 \u00d7 106 0.6629 Table 3: Training cost comparision with/without common feature trick Cost Without CF. With CF. Cost Saving Memory cost/node 89.2 GB 31 GB 65.2% Time cost/iteration 121s 10s 91.7% result. Meanwhile, models trained with di\ufb00erent norm get di\ufb00erent AUC performance. Again adding the two norms together the model reaches the best AUC performance. In this experiment, the hyper-parameter m is set to be 12. Parameters \u03b2 and \u03bb are selected by grid search. {0.01, 0.1, 1, 10} are tried for both norms in the all cases. The model with \u03b2 = 1 and \u03bb = 1 preforms best. 4.3 E\ufb00ectiveness of common feature trick We prove the e\ufb00ectiveness of common features trick. Speci\ufb01cally, we set up the experiments with 100 workers, each of which uses 12 CPU cores, with up to 110 GB memory totally. As shown in Table 3, compressing instances with common feature trick does not a\ufb00ect the actual dimensions of feature space. However, in practice we can signi\ufb01cantly reduce memory usage (reduce to about 1/3) and speed up the calculation (around 12 times faster) compared to the training without common feature trick. Figure 5: Model performance comparison on 7 di\ufb00erent test datasets. LS-PLM owns consistent and markable promotion compared with LR. 4.4 Comparison with LR We now compare LS-PLM with LR, the widely used CTR prediction model in product setting. The two models are trained using our distributed implementation architecture, running with hundreds of machines for speed-up. The choice of the L1 and L2,1 parameters for LS-PLM and the L1 parameter for LR are based on grid search. \u03b2 = 0.01, 0.1, 1, 10 and \u03bb = 0.01, 0.1, 1, 10 are tried. The best parameters are \u03b2 = 1 and \u03bb = 1 for LS-PLM, and \u03b2 = 1 for LR. 9 \fAs shown in Figure 5, LS-PLM outperforms LR clearly. The average improvement of AUC for LR is 1.44%, which has signi\ufb01cant impact to the overall online ad system performance. Besides, the improvement is stable. This ensures LS-PLM can be safely deployed for daily online production system. 5"
+                }
+            ]
+        },
+        "edge_feat": {}
+    }
+}
\ No newline at end of file