Whole-Chain Recommendations

TL;DR

This paper introduces DeepChain, a multi-agent, model-based reinforcement learning framework for optimizing sequential recommendations across multiple scenarios in e-commerce, improving overall session performance.

Contribution

It proposes a novel multi-agent, model-based RL approach that captures sequential correlations and jointly optimizes multiple recommendation strategies in whole-chain recommendations.

Findings

DeepChain outperforms existing methods on real e-commerce data.

The approach reduces data requirements compared to model-free RL.

Joint optimization improves overall session reward.

Abstract

With the recent prevalence of Reinforcement Learning (RL), there have been tremendous interests in developing RL-based recommender systems. In practical recommendation sessions, users will sequentially access multiple scenarios, such as the entrance pages and the item detail pages, and each scenario has its specific characteristics. However, the majority of existing RL-based recommender systems focus on optimizing one strategy for all scenarios or separately optimizing each strategy, which could lead to sub-optimal overall performance. In this paper, we study the recommendation problem with multiple (consecutive) scenarios, i.e., whole-chain recommendations. We propose a multi-agent RL-based approach (DeepChain), which can capture the sequential correlation among different scenarios and jointly optimize multiple recommendation strategies. To be specific, all recommender agents (RAs) share the same memory of users' historical behaviors, and they work collaboratively to maximize the overall reward of a session. Note that optimizing multiple recommendation strategies jointly faces two challenges in the existing model-free RL model - (i) it requires huge amounts of user behavior data, and (ii) the distribution of reward (users' feedback) are extremely unbalanced. In this paper, we introduce model-based RL techniques to reduce the training data requirement and execute more accurate strategy updates. The experimental results based on a real e-commerce platform demonstrate the effectiveness of the proposed framework.

Figures

Tables

Table 1. Table 1. Performance comparison of different recommender systems

Scenarios	Metrics	Algorithms
		W&D	DFM	GRU	DDPG	MA	DeepChain
Entrance Page	MAP	0.106	0.108	0.113	0.117	0.121	0.126
	improv.(%)	18.87	16.67	11.50	7.693	4.132	-
	p-value	0.000	0.000	0.000	0.000	0.003	-
Entrance Page	NDCG@40	0.189	0.193	0.201	0.209	0.215	0.225
	improv.(%)	19.05	16.58	11.95	7.656	4.651	-
	p-value	0.000	0.000	0.000	0.000	0.003	-
Item Detail Page	MAP	0.081	0.083	0.086	0.090	0.093	0.096
	improv.(%)	18.52	15.66	11.63	6.667	3.226	-
	p-value	0.000	0.000	0.000	0.000	0.006	-
Item Detail Page	NDCG@40	0.166	0.169	0.176	0.183	0.190	0.197
	improv.(%)	18.67	16.57	11.93	7.650	3.684	-
	p-value	0.000	0.000	0.000	0.000	0.005	-

Equations

$$Scor{e}_k=a_t{e}_k^{⊺},$$

$$y_t=$$

$$+$$

$$L(\mu)=\mathbb{E}_{s_{t},a_{t},r_{t},s_{t+1}}\big{(}y_{t}-Q_{\mu}(s_{t},a_{t})\big{)}^{2},$$

$${\nabla }_{\mu }L(\mu )$$

$${\mu }^{\prime }\leftarrow \tau \mu +(1-\tau ){\mu }^{\prime }$$

$${\pi }_m^{\prime }\leftarrow \tau {\pi }_m+(1-\tau ){\pi }_m^{\prime }$$

$${\pi }_b^{\prime }\leftarrow \tau {\pi }_b+(1-\tau ){\pi }_b^{\prime }$$

$$\nabla_{{\pi}}L(\pi)\approx\mathbb{E}_{s_{t}}\big{[}\nabla_{a_{t}}Q_{\mu}(s_{t},a_{t})\,\nabla_{{\pi}}{\pi}(s_{t})\big{]},$$

Full text

††journalyear: 2020††copyright: acmcopyright††conference: Proceedings of the 29th ACM International Conference on Information and Knowledge Management; October 19–23, 2020; Virtual Event, Ireland††booktitle: Proceedings of the 29th ACM International Conference on Information and Knowledge Management (CIKM ’20), October 19–23, 2020, Virtual Event, Ireland††price: 15.00††doi: 10.1145/3340531.3412044††isbn: 978-1-4503-6859-9/20/10

1. Introduction

With the recent tremendous development in Reinforcement Learning (RL), there have been increasing interests in adapting RL for recommendations. RL-based recommender systems treat the recommendation procedures as sequential interactions between users and a recommender agent (RA). They aim to automatically learn an optimal recommendation strategy (policy) that maximizes cumulative rewards from users without any specific instructions. RL-based recommender systems can achieve two key advantages: (i) the RA can learn their recommendation strategies based on users’ real-time feedback during the user-agent interactions continuously; and (ii) the optimal strategies target at maximizing the long-term reward from users (e.g. the overall revenue of a recommendation session). Therefore, numerous efforts have been made on developing RL-based recommender systems (Zhao et al., 2018b, 2017, a; Dulac-Arnold et al., 2015; Fan et al., 2020; Feng et al., 2018).

In reality, as shown in Figure 1, users often sequentially interact with multiple RAs from different scenarios in one recommendation session. First, a user usually starts a recommendation session by browsing the recommended items in the entrance page of the E-commerce platform, which suggests diverse and complementary items according to the user’s browsing history where the user can: (i) skip the recommended items and continue browsing the new recommendations, or (ii) go to the item detail page if she clicks one preferred item. Second, the item detail page shows the details of the clicked item, and the RA of this page recommends a set of items related to the clicked item where the user can (i) go back to the entrance page, (ii) go to another item detail page if she clicks one recommended item, or (iii) add the item into the shopping cart and go to the shopping cart page. Third, the shopping cart page lists all items that the user have added, and an RA generates recommendations associated with these items where the user can (i) return to the last item detail page, (ii) click one recommended item and go the item detail page, or (iii) go to the order page if she decides to purchase some items. Finally, after purchasing items in the order page, an RA will recommend a set of items related to the purchased items. Note that (i) the user will be navigated to an item detail page wherever she clicks a recommended item, and (ii) the user can leave the platform at any scenarios (we only show one “leave” behavior in Figure 1).

The real example suggests that there is a chain of recommendation scenarios and these scenarios are sequentially related. However, the majority of traditional methods usually only optimize one recommendation strategy for all scenarios or independently optimize each recommendation strategy based on the data from each scenario (Zhao et al., 2020a; Zhao et al., 2019a; Zou et al., 2020b; Zhao et al., 2019b, 2020c, 2020b, 2018b, 2017, 2018a, c; Zheng et al., 2018; Zou et al., 2020a; Zou et al., 2019), which could result in sub-optimal overall performance. First, from the above example, different scenarios have independent objectives, e.g., the entrance page focuses on the trade-off between correlation and diversity while the item detail page focuses more on correlation, thus optimizing only one strategy for all scenarios is sub-optimal. Second, separate optimization ignores the sequential correlation and dependency of users’ behaviors among different scenarios. Third, optimizing one strategy within a specific scenario only leverages the user-agent interaction data within this scenario, while completely ignoring the information (users’ behaviors) from other scenarios. Finally, independent optimization of one scenario only maximizes its objective, which may negatively affect the overall objective of the whole recommendation session. In other words, recommending an item in one specific scenario may negatively influence user’s click/purchase behaviors in other scenarios. Thus, in this paper, we formulate the recommendation tasks within multiple consecutive scenarios as a whole-chain recommendation problem, and leverage multi-agent reinforcement learning (MARL) to jointly optimize multiple recommendation strategies, which is capable of maximizing the overall performance of the whole recommendation session. The designed whole-chain recommendation framework (DeepChain) has three advantages. First, RAs are sequentially activated to capture the sequential dependency of users’ behaviors among different scenarios. Second, all RAs in different scenarios share the same memory of historical user behavior data, in other words, an RA in one scenario can leverage user behavior data from other scenarios to make more accurate decisions. Third, all RAs can jointly work to optimize the overall performance of the whole recommendation session.

In order to optimize recommendation strategies, existing model-free RL-based recommender systems typically require a larger amount of user-agent interaction data (Dulac-Arnold et al., 2015; Zhao et al., 2018b; Zheng et al., 2018; Feng et al., 2018). The whole-chain setting with multiple scenarios demands even more data. However, this requirement is challenging in practical recommendation systems, since real-world users will leave the platforms quickly if the systems randomly recommend items that cannot fit users’ preferences (Chen et al., 2018c). Furthermore, the distributions of users’ immediate feedback (reward) on the recommended items are extremely unbalanced in users’ historical logs, since users’ click/purchase behaviors (with positive reward) occur much infrequently than users’ skip behaviors (with zero reward). This will lead to an inaccurate update of the action-value function of RL (Hu et al., 2018). Therefore, to tackle these challenges, in this paper, we propose a model-based RL framework for the MARL-based recommender systems (DeepChain). Compared with model-free models (e.g. (Feng et al., 2018)), the model-based framework approximates the user behaviors (environment) to reduce training data amount requirement and performs accurate optimization of the action-value function. We demonstrate the effectiveness of the proposed framework on a real-world dataset from an e-commerce platform JD.com, and validate the importance of the components in DeepChain for accurate recommendations.

2. Problem Statement

We formulate the whole-chain recommendation task as a multi-agent model-based RL problem. To be specific, there exist several RAs corresponding to different recommendation scenarios. Each RA serves as a recommendation strategy that recommends items to a user (the environment $\mathcal{E}$) in a specific scenario. Furthermore, the RAs sequentially interact with the user by recommending items over a sequence of time steps, thus the RAs are sequentially activated according to the user’s behaviors, and only one RA is activated at each time step. All RAs work cooperatively to maximize the cumulative reward of a recommendation session. In this paper, we model the above multi-agent model-based RL problem as a Markov Decision Process (MDP), which contains a sequence of states, actions and rewards. Formally, the MDP is a tuple with five elements $(\mathcal{S},\mathcal{A},\mathcal{P},\mathcal{R},\gamma)$ as:

• •

State space $\mathcal{S}$: The state $s_{t}\in\mathcal{S}$ is defined as a chronologically sorted sequence of a user’s historical clicked or purchased items before time $t$, which represents the user’s preference at time $t$.

• •

Action space $\mathcal{A}$: An action $a_{t}\in\mathcal{A}$ of an RA is recommending a list of relevant items corresponding to state $s_{t}$. Without the loss of generality, in this paper, each time an RA recommends only one item to the user, while it is straightforward to extend the setting to recommend multiple items.

• •

Reward $\mathcal{R}(\mathcal{S}\times\mathcal{A}\rightarrow\mathbb{R})$: When an RA recommends an item to a user at time $t$ (i.e. taking action $a_{t}$), the user will browse the recommended item and provide corresponding feedback (such as skip, click, purchase or leave), and then the RA will receive an immediate reward $r(s_{t},a_{t})$ based on the user’s feedback.

• •

Transition probability $\mathcal{P}(\mathcal{S}\times\mathcal{A}\times\mathcal{S}\rightarrow[0,1])$: Transition probability $p(s_{t+1}|s_{t},a_{t})$ is defined as the probability of state transiting from $s_{t}$ to $s_{t+1}$ when action $a_{t}$ is executed by an RA. The MDP is assumed to satisfy the Markov property $p(s_{t+1}|s_{t},a_{t},...,s_{1},a_{1})=p(s_{t+1}|s_{t},a_{t})$. In our setting, the transition probability is equivalent to user behavior probability, which is also associated with the activation of RAs.

• •

Discount factor $\gamma$: the reward discount factor $\gamma\in[0,1]$ is leveraged to calculate the present value of future reward. When $\gamma=1$, all future rewards can be fully counted into the current action; when $\gamma=0$, only the immediate reward is considered.

With the aforementioned definitions and descriptions, we formally define the whole-chain recommendation problem as follows: Given the historical MDP, i.e., $(\mathcal{S},\mathcal{A},\mathcal{P},\mathcal{R},\gamma)$, the goal is to find a set recommendation policies $\{\pi\}:\mathcal{S}\rightarrow\mathcal{A}$ for multiple recommender agents of different recommendation scenarios, which can maximize the cumulative reward of the whole recommendation session.

3. The Proposed Framework

In this section, we will propose a deep RL approach for the whole-chain recommendation problem, which can simultaneously learn multiple recommendation strategies for different scenarios by a model-based RL algorithm. As discussed in Section 1, developing a whole-chain recommendation framework is challenging, because (i) optimizing only one strategy for all scenarios overlooks the different objectives of different scenarios, (ii) optimizing each strategy for each scenario separately neglects the sequential correlation among scenarios and the information from other scenarios, and solely optimizes its objective may lead to the sub-optimal overall performance of the whole session, and (iii) jointly optimizing multiple recommendation strategies requires substantial user behavior data, and the users’ feedback (reward) distributions are extremely unbalanced. To address these challenges, we propose a multi-agent model-based RL framework. Note that for the sake of simplicity, we will only discuss the recommendations within two scenarios, i.e., entrance page and item detail page, however, it is straightforward to extend the setting with more scenarios. In the following, we will first illustrate the overview of the proposed framework, then introduce the architectures of RAs (actors) and critic separately, and finally we will discuss the objective function with its optimization.

3.1. An Overview of the Proposed Framework

The multi-agent RL framework with Actor-Critic architecture is illustrated in Figure 2. In our setting, the proposed framework has two RAs (actors), i.e., $Actor_{m}$ providing recommendations in the entrance page and $Actor_{d}$ for the recommendations in the item detail page. Actors aim to generate recommendations according to users’ browsing histories (state). As mentioned in Section 1: (i) the RAs are sequentially activated to interact with users, (ii) the RAs share the same memory of users’ historical behavior data (state), and (iii) the RAs will work jointly to maximize the overall performance, which is evaluated by a global action-value function (critic). In other words, a global critic controls all actors to enable them to work collaboratively to optimize the same overall performance. To be specific, the critic takes the current state-action pair as the input, and outputs an action-value to evaluate the long-term future rewards corresponding to the current state and action. Next, we will discuss their architecture.

3.2. The Actor Architecture

The goal of the actors is to suggest recommendations based on users’ historical browsing behaviors (state), which should address two challenges: (i) how to capture users’ dynamic preference in one recommendation session, and (ii) how to generate recommendations according to the learned users’ preference. To tackle these challenges, we develop a two-stage framework, where the first stage (i.e. actor) aims to learn users’ dynamic preferences, and the second stage targets to generate recommendations. Note that all actors share the same architecture with different parameters.

3.2.1. First-stage: Actor to Capture Users’ Preference

The sub-figure under the dash line of Figure 3 illustrates the actor architecture that aims to learn users’ dynamic preferences during the recommendation session. The actor takes the item representations111The item representations $\{e_{1},\cdots,e_{N}\}$ are dense and low-dimensional vectors, which are pre-trained based on users’ browsing history via word embedding (Levy and Goldberg, 2014), where the clicked items in one recommendation session are treated as a sentence, and each item is treated as a word. of users’ previously clicked or purchased items $\{e_{1},\cdots,e_{N}\}$ ($e_{n}\in\mathbb{R}^{|E|}$) in sequential order as inputs , and will output the representations of users’ dynamic preference in the form of a dense and low-dimensional vector. We introduce a recurrent neural network (RNN) with Gated Recurrent Units (GRU) to capture users’ sequential browsing behaviors. To capture user’s attention in current session, we introduce an item-level attention mechanism (Li et al., 2017), where the actor could dynamically combine the hidden states $\{h_{1},\cdots,h_{n}\}$ of RNN to generate the action $a_{t}\in\mathbb{R}^{|H|}$.

3.2.2. Second-stage: Recommendation Generation

The sub-figure above the dash line of Figure 3 illustrates the recommendation generation stage, which targets to generate recommendations according to users’ preference learned by the Actor. To be specific, a similarity function between the representations of user’s current preference $a_{t}$ and each candidate item is proposed to calculate a similarity score:

[TABLE]

Then we select the item with the highest similarity score as the output of the second stage, i.e., the next item to be recommended according to users’ current preference. Note that we adopt an item-recall mechanism to reduce the number of relevant items 222 In general, user’s preference in current session should be related to user’s previously clicked/purchased items before the current session (say $\mathcal{L}$). Thus for each item in $\mathcal{L}$, we collect a number of most similar items in terms of cosine similarity from the whole item space, and combine all collected items as the initial item space $\mathcal{I}$ of current recommendation session. During the current session, when a user clicks or purchases an item, we will also add a number of its most similar items into the item space $\mathcal{I}$.. Next, we will discuss the architectures of the critic.

3.3. The Critic Architecture

The RAs introduced in Section 3.2 should work collaboratively to optimize the same overall objective, which is measured by a global critic network (action-value function). In other words, the global critic will control all RAs to work cooperatively to maximize the global performance. Specifically, the input of critic is the current state-action pair $(s_{t},a_{t})$, and the output is an action-value $Q(s_{t},a_{t})$ that evaluates the future cumulative rewards starting from the current state and action. According to the $Q(s_{t},a_{t})$, the actors will update their parameters to generate more accurate recommendations, which will be discussed in the following subsections. The global critic should tackle one challenge, i.e., how to capture user’s preferences in different scenarios. In other words, users in different scenarios have different preferences, even though they have the same browsing histories.

Figure 4 illustrates the architecture of the global critic, which takes the current state $s_{t}$ and action $a_{t}$ as input. We follow the same strategy to feed the item representations of users’ previously clicked/purchased items $\{e_{1},\cdots,e_{N}\}$ into an RNN with GRU units. Note that the RNNs in actors and global critic share the same architecture with independent parameters. In order to tackle the aforementioned challenge, we introduce two separate item-level attention mechanisms for the entrance page and the item detail page. The intuition is that user’s preference in different scenarios is influenced by different parts of her/his browsing histories (i.e. different attention patterns). In other words, we will obtain different representations of user’s preferences in different scenarios. The mutually-exclusive indicators $\mathbf{1_{m}}$ and $\mathbf{1_{d}}$ will control the activation of two attention mechanisms, i.e., only one attention mechanism is activated each time. Next, we will concatenate the users’ preference $p_{C}$ and current action $a_{t}$, and feed them into several fully connected layers as a nonlinear approximator to estimate the action-value function $Q(s_{t},a_{t})$.

3.4. The Optimization Task

In this subsection, we will discuss the objective functions with the optimization algorithm. As mentioned in Section 1, the majority of existing model-free RL-based recommender systems need huge amounts of users’ behavior data. It is hard to be satisfied in the practical business, because real users will leave the system quickly if they receive almost randomly recommended items, which frequently happens in the initial model training (exploration) stage. Furthermore, since users’ skip behaviors (with zero reward) occur much frequently than users’ click/purchase behaviors (with positive reward), the distributions of immediate reward function $r_{t}(s_{t},a_{t})$ are extremely unbalanced, which can result in an inaccurate update of action-value function. Therefore, we proposed a model-based RL framework for the whole-chain recommendation system, which can approximate the environment (user behaviors) to reduce the desired training data amount and perform more accurate optimization of the action-value function (Brafman and Tennenholtz, 2002; Kearns and Singh, 2002; Hu et al., 2018).

Under our setting with two scenarios, i.e., the entrance page and the item detail page, users have three types of behaviors in each scenario. In the entrance page, given a recommended item based on the current state $s_{t}$, users can: (i) skip the item and continue browsing in the entrance page with a probability $p_{m}^{s}(s_{t},a_{t})$, (ii) click the item and go to the item detail page with probability $p_{m}^{c}(s_{t},a_{t})$, or (iii) leave the session with probability $p_{m}^{l}(s_{t},a_{t})$. Similarly, in the item detail page, given a state-action pair, users can: (i) click the item and go to another item detail page with probability $p_{d}^{c}(s_{t},a_{t})$, (ii) skip the item and go back to the entrance page with the probability $p_{d}^{s}(s_{t},a_{t})$, or (iii) leave the session with probability $p_{d}^{l}(s_{t},a_{t})$. Then the approximation (target) of the action value function, referred as to $y_{t}$, can be formulated as follows:

[TABLE]

where the mutually-exclusive indicators $\mathbf{1_{m}}$ and $\mathbf{1_{d}}$ control the activation of two scenarios. Notations $\pi^{\prime}_{m}$, $\pi^{\prime}_{d}$ and $\mu^{\prime}$ represent the parameters of the target network of $Actor_{m}$, $Actor_{d}$ and Critic respectively of the DDPG framework (Lillicrap et al., 2015). In the Eq (2), the first row corresponds to the “skip” behavior in entrance page that leads to a nonzero Q-value, and the $Actor_{m}$ will continue recommending next item according to new state $s_{t+1}$; the second row corresponds to the “click” behavior in the entrance page that leads to a positive immediate reward and a nonzero Q-value, and $Actor_{d}$ is activated to recommend next item; the third row corresponds to the “leave” behavior in the entrance page that leads to a negative immediate reward, and the session ends; the fourth row corresponds to the “click” behavior in the item detail page that leads to a positive immediate reward and a nonzero Q-value, and $Actor_{d}$ will continue recommending next item; the fifth row corresponds to the “skip” behavior in the item detail page that leads to a nonzero Q-value, and $Actor_{m}$ is re-activated to generate next recommendation; the last row corresponds to the “leave” behavior in the item detail page that leads to a negative immediate reward, and the session ends.

We leverage the off-policy DDPG algorithm (Lillicrap et al., 2015) to update the parameters of the proposed Actor-Critic framework based on the samples stored in a replay buffer (Mnih et al., 2015), and we introduce separated evaluation and target networks (Mnih et al., 2013) to help smooth the learning and avoid the divergence of parameters. Next, we will discuss the optimization of user behavior probabilities, actors and critic.

3.4.1. Estimating the State Transition Probability

In fact, user behavior probabilities $[p_{m}^{c}(s_{t},a_{t}),p_{m}^{s}(s_{t},a_{t}),p_{m}^{l}(s_{t},a_{t})]$ and $[p_{d}^{c}(s_{t},a_{t}),$ $p_{d}^{s}(s_{t},a_{t}),p_{d}^{l}(s_{t},a_{t})]$ are state transition probabilities introduced in Section 2. In other word, users’ different behaviors result in different state transitions. We develop one probability network, to estimate the state transition probabilities. The architecture is similar with the critic network shown in Figure 4, which takes current state-action pair as input, while the only difference is that the output layer has two separate softmax layers that predicts the state transition probabilities of two scenarios. To update the parameters of probability networks, we leverage supervised learning techniques as standard model-based RL, which minimize the cross entropy loss between predicted probability vector and ground truth one-hot vector (e.g. $[1,0,0]$ represents “click” behavior).

3.4.2. Optimizating the Critic Parameters

The critic, i.e., the action value function $Q_{\mu}(s_{t},a_{t})$, can be optimized by minimizing the loss functions $L(\mu)$ as follows:

[TABLE]

where $\mu$ represents all the parameters of critic (evaluation network), and $y_{t}$ is defined in Eq (2). The parameters $\pi^{\prime}_{m}$, $\pi^{\prime}_{d}$ and $\mu^{\prime}$ learned from the previous iteration and the state transition probabilities in Eq (2) are fixed when optimizing the loss function $L(\mu)$. The derivative of the loss function $L(\mu)$ with respective to parameters $\mu$ is presented as follows:

[TABLE]

3.4.3. Optimizating the Actor Parameters

The actors can be updated by maximizing $Q_{\mu}(s_{t},a_{t})$ using the policy gradient:

[TABLE]

where $\pi$ can represent the parameters of $Actor_{m}$ or $Actor_{d}$.

3.4.4. The Training Algorithm

The off-policy training algorithm for DeepChain is presented in Algorithm 1. In each iteration, there are two stages, i.e., 1) transition generating stage (lines 7-8), and 2) parameter updating stage (lines 9-15). For transition generating stage: we first observe the transition $(s_{t},a_{t},r_{t},s_{t+1})$ following offline behavior policy $b(s_{t})$ that generates the historical behavior data (line 7), then we store the transition $(s_{t},a_{t},r_{t},s_{t+1})$ into the replay buffer $\mathcal{D}$ (line 8). For parameter updating stage: we first sample mini-batch of transitions $(s,a,r,s^{\prime})$ from $\mathcal{D}$ (line 9), then we update the state transition probabilities by supervised learning techniques as mentioned in Section 3.4.1 (line 10), and finally we update critic and actors (lines 11-14) following a standard DDPG procedure (Lillicrap et al., 2015). Note that it is straightforward to extend the off-policy training to on-policy training: in transition generating stage, we can collect transitions $(s_{t},a_{t},r_{t},s_{t+1})$ with exploration during the interactions between RAs and real users.

3.5. The Test Tasks

In this subsection, we will present the test tasks of the DeepChain framework. We propose two test tasks, i.e., (i) Offline test: testing the proposed framework based on user’s historical behavior data; and (ii) Online test: testing the proposed framework in a real online environment where the RAs interact with real-world users and receive an immediate reward (real-time feedback) of the recommended items from users. Note that offline test is necessary because recommendation algorithms should be pre-trained (by the off-policy algorithm in Section 3.4) and evaluated offline before launching in the real online system, which ensures the recommendation quality and mitigates the negative influence on user experience.

3.5.1. Online Test

The online test algorithm is presented in Algorithm 2. In each iteration of a recommendation session, given the current state $s_{t}$ and scenario, one actor is activated to recommend an item to user following policy ${\pi_{m}}$ or ${\pi_{b}}$ (line 5 or 7). Then the system observes the reward $r_{t}$ from user and updates the state to $s_{t+1}$ (line 9).

3.5.2. Offline Test

The intuition of offline test is that, given historical offline recommendation session data, if DeepChain works well, it can re-rank the items in this session and the ground truth clicked items can be sorted at the top of the new list. The DeepChain only re-ranks items in this session rather than all items from item space, because we only know the ground truth rewards corresponding to the existing items of this session in the offline data. The offline test algorithm is presented in Algorithm 3. In each iteration, given $s_{t}$, the actor recommends an item to user following policy ${\pi}$ (line 4), where we calculate the recommending score of all items in the item list $\mathcal{I}$, and select the one with the highest score. Then we add the selected item into a new recommendation list $\mathcal{L}$ (line 5), and record reward $r_{t}$ from historical data (line 6). Next we update the state to $s_{t+1}$ (line 7). Finally, we remove the selected item from $\mathcal{I}$ (line 8), which avoids repeatedly recommending the same items. Note that in an offline test setting, we collect user behavior data in two scenarios and re-rank the items in each scenario.

4. Experiment

In this section, we conduct extensive experiments to evaluate the effectiveness of the proposed framework based on a real e-commerce platform. We mainly focus on two questions: (1) how the proposed framework performs compared to the state-of-the-art baselines; and (2) how the components in the framework contribute to the performance. We first introduce experimental settings. Then we seek answers to the above two questions. Finally, we study the impact of key parameters on the performance of the proposed framework.

4.1. Experimental Settings

We collected a real-world dataset of December 2018 from an e-commerce platform, JD.com. We randomly collect 500,000 recommendation sessions (with 19,667,665 items) in temporal order, and leverage the first 80% sessions as the training/validation datasets and the later 20% sessions as the (offline) test dataset. For a new session, the initial state $s_{1}$ is $N=50$ previously clicked or purchased items obtained from users’ previous sessions (Guo et al., 2020). The immediate reward $r_{t}$ of click/skip/leave behavior is empirically set as 1, 0, and -2, respectively. The dimensions of item representation vector and hidden state of RNN are $|E|=20$ and $|H|=64$. The discounted factor $\gamma=0.95$, and the soft update rate for target networks is $\tau=0.01$. We select the parameters of the DeepChain framework via cross-validation, and do parameter-tuning for baselines for a fair comparison. More details about parameter analysis will be discussed in the following subsections. For offline test, we select NDCG (Järvelin and Kekäläinen, 2002) and MAP (Turpin and Scholer, 2006) as metrics. For online test, we use the overall reward in one recommendation session as the metric.

4.2. Performance Comparison for Offline Test

We compare the proposed framework with the following representative baseline methods:

• •

W&D (Cheng et al., 2016): This baseline is a wide & deep model for jointly training feed-forward neural networks with embeddings and linear model with feature transformations for generic recommender systems with sparse inputs.

• •

DFM (Guo et al., 2017): DeepFM is a deep neural network model that integrates the architectures of factorization-machine (FM) and wide & deep model. It models low-order feature interactions like FM and models high-order feature interactions like W&D.

• •

GRU (Hidasi et al., 2015): GRU4Rec leverages the RNN with GRU to predict what a user will click next based on the clicking history. We also keep $N=50$ clicked items as the state for a fair comparison.

• •

DDPG (Dulac-Arnold et al., 2015): This baseline is the conventional Deep Deterministic Policy Gradient. The input for Actor is the concatenation of embeddings of users’ historical clicked items (state). The input for Critic is the concatenation of the state and a recommended item (action).

• •

MA (Lowe et al., 2017): This is a multi-agent model-free RL model, where agents learn a centralized critic based on the observations and actions of all agents.

The results are shown in Table 1. Note that in the offline test, we separately collect user behavior data from two scenarios and re-rank the items in each scenario by the corresponding RA. We make the following observations: (i) The DFM achieves better performance than W&D, where DeepFM can be trained end-to-end without any feature engineering, and its wide part and deep part share the same input and also the embedding vector. (ii) GRU outperforms W&D and DFM, since GRU can capture the temporal sequence within one recommendation session, while W&D and DFM neglect it. (iii) DDPG achieves better performance than GRU, since DDPG can optimize the overall performance of one recommendation session, but GRU only maximizes the immediate reward for next recommended item. This result validates the advantage of RL techniques in recommendations. (iv) DDPG performs worse than MA and DeepChain, because DDPG trains each RA in each scenario separately, while MA and DeepChain are multi-agent models where RAs are jointly trained on two scenarios (the whole dataset) to optimize the global performance. (v) DeepChain outperforms MA, since model-based RL model like DeepChain can perform more accurate optimization of the action-value function based on less training data. To sum up, DeepChain outperforms representative baselines, which demonstrates its effectiveness in recommendations.

4.3. Performance Comparison for Online Test

Following (Zhao et al., 2018b, a), we evaluate the proposed framework on a simulated online environment, where a deep neural network is pre-trained to estimate users’ behaviors based on historical state-action pairs. Furthermore, to answer the second question, we systematically eliminate the corresponding components of DeepChain by defining the following two variants:

• •

DC-o: This variant is a one-agent version of DeepChain. In other words, only one RA is trained to generate recommendations on both the entrance page and item detail page.

• •

DC-f: This variant is a model-free version of DeepChain, which does not estimate the user behavior probabilities as mentioned in Section 3.4.1.

The results are shown in Figure 5. It can be observed: (i) We observe similar online test comparison results between DeepChain and the state-of-the-art baselines as these in the offline test in Figure 5 (a). (ii) DC-o performs worse than DeepChain, since DC-o only trains one RA for both two scenarios. This result indicates that users’ interests in different scenarios are different. Thus developing separate RAs for different scenarios is necessary. (iii) DC-f achieves worse performance than DeepChain. The key reasons include: (iii-a) model-free version DC-f requires more training data, as illustrated in Figure 5(c), DC-f converges much slower than DeepChain; and (iii-b) DC-f performs less accurate optimization of $Q(s_{t},a_{t})$ than model-based model DeepChain. This result validates the effectiveness of model-based RL in recommendations. In summary, appropriately developing separate RAs and introducing model-based techniques to update action-value function can boost the recommendation performance.

4.4. Parameter Sensitivity Analysis

In this subsection, we investigate how the proposed framework DeepChain performs with the changes of $N$, i.e., the length of users’ browsing history (state), while fixing other parameters.

We can observe: (i) Figure 6 (a) demonstrates the parameter sensitivity of $N$ in online test. We can find that with the increase of $N$, the overall performance improves. (ii) Figure 6 (b) shows the parameter sensitivity of $N$ in the offline test task. We can observe that the recommendation performance of the entrance page is more sensitive with the increase of $N$ than that of the item detail page. The reason is that users’ interests are different in two scenarios: in the entrance page, users’ preferences are diverse, thus including longer browsing history can better discover users’ various interests; while in one specific item’s detail page, users’ attention mainly focuses on the similar items to this specific item, in other words, users would like to compare this item with similar ones, thus involving longer browsing history cannot significantly improve the performance.

5. Related Work

In this section, we briefly review works related to our study, i.e., RL-based recommender systems (Zhao et al., 2019c; Zhang et al., 2020). Practical recommender systems are always with millions of items (discrete actions) to recommend. Thus, most RL-based models will become inefficient since they are not able to handle such a large discrete action space. A Deep Deterministic Policy Gradient (DDPG) algorithm is introduced to mitigate the large action space issue in practical RL-based recommender systems (Dulac-Arnold et al., 2015). To avoid the inconsistency of DDPG and improve recommendation performance, a tree-structured policy gradient is proposed in (Chen et al., 2018b). Biclustering technique is also introduced to model recommender systems as grid-world games so as to reduce the state/action space (Choi et al., 2018). To solve the unstable reward distribution problem in dynamic recommendation environments, approximate regretted reward technique is proposed with Double DQN to obtain a reference baseline from individual customer sample (Chen et al., 2018d). Users’ positive and negative feedback, i.e., purchase/click and skip behaviors, are jointly considered in one framework to boost recommendations, since both types of feedback can represent part of users’ preference (Zhao et al., 2018b). A page-wise recommendation framework is proposed to jointly recommend a page of items and display them within a 2-D page (Zhao et al., 2017, 2018a). CNN technique is introduced to capture the item display patterns and users’ feedback of each item in the page. In the news feed scenario, a DQN based framework is proposed to handle the challenges of conventional models, i.e., (1) only modeling current reward like CTR, (2) not considering click/skip labels, and (3) feeding similar news to users (Zheng et al., 2018). An RL framework for explainable recommendation is proposed in (Wang et al., 2018), which can explain any recommendation model and can flexibly control the explanation quality based on the application scenario. A policy gradient-based top-K recommender system for YouTube is developed in (Chen et al., 2018a), which addresses biases in logged data through incorporating a learned logging policy and a novel top-K off-policy correction. In (Feng et al., 2018), multi-scenario ranking is formulated as a fully cooperative, partially observable, multi-agent sequential decision problem, denoted as MA-RDPG. While similar in motivation to our approach, it is on the top of model-free approach, which requires a larger amount of user-agent interaction data and suffers from inaccurate update of the action-value function. Other RL-based recommendation applications include sellers’ impression allocation (Cai et al., 2018a), and fraudulent behavior detection (Cai et al., 2018b).

6. Conclusion

In this paper, we propose a novel multi-agent model-based reinforcement learning framework (DeepChain) for the whole-chain recommendation problem. It is able to collaboratively train multiple RAs for different scenarios by a model-based optimization algorithm. Multi-agent RL-based recommender systems have three advantages: (i) the RAs are sequentially activated to capture the sequential dependency of users’ behaviors among different scenarios; (ii) the RAs share the same memory of users’ historical behavior information to make more accurate decisions, and (iii) the RAs will work collaboratively to maximize the global performance of one recommendation session. Note that we design a model-based RL optimization algorithm that can reduce the requirement of training data and perform more accurate optimization of the action-value function than model-free algorithms. We conduct extensive experiments based on a real-world dataset from an e-commerce platform. The results show that (i) DeepChain can significantly enhance the recommendation performance; and (ii) multi-agent techniques and model-based RL can enhance the recommendation task.

ACKNOWLEDGEMENTS

This work is supported by National Science Foundation (NSF) under grant numbers IIS1907704, IIS1928278, IIS1714741, IIS1715940, IIS1845081 and CNS1815636.