Rank-to-engage: New Listwise Approaches to Maximize Engagement
Swayambhoo Jain Akshay Soni Nikolay Laptev Yashar Mehdad

	Three-particle correlations in relativistic heavy ion collisions in a multiphase transport model
    Che Ming Ko
    December 30, 2023
================================================================================================


For many internet businesses, presenting a given list of items in an order that maximizes a certain metric of interest (e.g., click-through-rate, average engagement time etc.) is crucial. We approach the aforementioned task from a learning-to-rank perspective which reveals a new problem setup.  In traditional learning-to-rank literature, it is implicitly assumed that during the training data generation one has access to the best or desired order for the given list of items.  In this work, we consider a problem setup where we do not observe the desired ranking. We present two novel solutions: the first solution is an extension of already existing listwise learning-to-rank technique–Listwise maximum likelihood estimation (ListMLE)–while the second one is a generic machine learning based framework that tackles the problem in its entire generality. We discuss several challenges associated with this generic framework, and  propose a simple item-payoff and positional-gain model that addresses these challenges. We provide training algorithms, inference procedures, and demonstrate the effectiveness of the two approaches over traditional ListMLE on synthetic as well as on real-life setting of ranking news articles for increased dwell time.






§ INTRODUCTION

Recommending items that matches users interests lies at the core of many online businesses and has been an active area of research; over the years, many techniques have been developed for these tasks including matrix completion based collaborative filtering <cit.>, factorization machines <cit.>, etc. The central theme of these techniques is that they utilize the historical data of user-engagement to predict user's interest or rating for the new items. These items are then presented to the users in the decreasing order of the predicted rating/score. It is implicitly assumed that the decreasing order of predicted score is the best order to show the items to the users. However, our real life experience suggests that in many scenarios user satisfaction is driven not just by the quality of items but also by the order in which they are presented to the users. In scenarios where the intention is better long-term user-engagement or revenue per user, once the most relevant set of items to be shown to the user are identified, the important task is to show these items in an order that maximizes a particular metric of interest, such as average time spent by users per session (each session is a ordered list of items), or total click through rate, etc.

The problem setup in such scenarios can be abstractly represented as in Figure <ref>, where the list of n items denoted by a feature matrix  = [_1,⋯, _n] ∈^d × n (_i ∈^d is the i^th column that is the feature vector of the i^th item in the list), is shown to a user in the input order Π∈_n (where _n is the set of all permutations of integers {1,⋯,n}). The user assesses the quality of the  items and the input order pair, (,Π), and assigns  a score s ∈^+ that is a measure of desired metric for (,Π). This results in a training example {(,Π) , s }. Depending on the specific setting, the user may assign the score explicitly or it may be calculated based on user interaction statistics, for example, in terms of clicks (or no clicks) or the average user engagement times. Using the training examples collected in this manner, the ultimate goal is to predict an order for a new unseen list of items so that the score is maximized. A similar looking problem is the focus point of various techniques developed in learning-to-rank literature but our problem setup is different as it violates an implicit assumption prevalent in learning-to-rank literature: the assumption that best or desired order is provided with training data however in our problem setup we do not have such data.

Our main contributions are two machine learning based solutions for the proposed problem setup. The first solution, weighted ListMLE, builds upon a popular listwise learning-to-rank technique ListMLE <cit.> by incorporating the weights proportional to the scores.  The second solution is a general machine learning framework in which we address the problem at hand in its entire generality. In this we first learn a mapping to predict the score for a given list of items and an order. The final order is obtained by maximizing the predicted score. We reveal several challenges associated with this approach and propose a simple item-payoff and positional-gain model that addresses these specific challenges. We also present an alternating-minimization based training algorithm and demonstrate the effectiveness of the proposed techniques on simulated as well as real datasets. 



 §.§ Related works

The problem setup we consider lies at the nexus of recommendation and ranking systems. It arises in the context of recommendation systems and is motivated by the learning-to-rank approaches. However, our problem setup is quite different from these traditional settings. As discussed earlier, typically in recommendation systems the items are presented in decreasing order of the predicted ratings. Recommendation techniques that give preference to diversity <cit.> or the multi-criteria recommender systems <cit.> often deviate from “decreasing order of predicted rating" ranking of items. But even in these systems, the input order is not explicitly modeled as considered in this paper. 

Our problem is also related to the learning-to-rank literature. Traditionally, learning-to-rank problems are motivated from a search engine perspective, where the task of is to show the results in decreasing order of relevance to the user's query. The main goal is to minimize the user's search time. The abstract problem setup arising in learning-to-rank literature is shown in Figure <ref>, where the user is shown the list of items 𝐗 and the user assigns relevance scores {s_i}_i=1^n to each item for the given query and provides best order based on decreasing order of relevance scores. In this manner training data comprising of lists of items and the final order can be collected. In some cases, however, access to the individual relevance scores is not necessary and the desired order can be inferred using other techniques <cit.>.  Variety of machine learning based learn-to-rank algorithms have been developed that use this training data to predict order for a new list of items. The main challenge in applying machine learning to rank list of items is the combinatorial nature of the output domain of the mapping. Existing techniques use different ways to deal with this challenge and can be broadly classified into three main categories: pointwise, pairwise, and listwise ranking <cit.>.

The pointwise approaches reduce the problem of ranking to regression tasks. They ignore the combinatorial output domain, and focus on predicting the relevance score of each item separately. Some of the important pointwise techniques are proposed in <cit.> among many others. The pairwise approaches on the other hand reduce the learning-to-rank problem to a classification problem by using pairwise comparisons to transform the order into binary labels. Few notable pairwise approaches among many others include support vector machine (SVM) based approach <cit.>, perceptron based approach <cit.> and neural networks based approach <cit.>. Listwise approaches take an entire list of items as input and directly tackle the combinatorial nature of output domain. Due to this, the listwise approaches are known to perform better than the pointwise and pairwise approaches. These are generally based on probabilistic modeling of various orders for the given list of items. Some notable works in listwise learning-to-rank are <cit.>. The pursuit to minimize the loss functions defined permutation spaces has lead to several listwise learning-to-rank techniques including LambdaRank <cit.> and several other followup works <cit.>. 

A distinguishing characteristic of traditional learning-to-rank problem setup is that the relevance of items to a query is a property of the items and does not change with the order in which the items are shown to the user. This is the main difference between our problem setup and existing learning-to-rank setup. We have the notion of input order whereas no such notion exists in problems discussed in learning-to-rank  literature. Also, in learning-to-rank literature it is implicitly assumed that during the training data generation one has access to the best or desired order for the given list of items. The existing learning-to-rank techniques mainly focus on predicting this order in various ways. In our problem setup we do not have access to the best or desired order for the items in a list. Due to these reasons  traditional learning-to-rank approaches are incapable of handling our problem setting.  







 §.§ Organization

Followed by brief discussion on notation in section <ref>, we discuss the problem formulation in section <ref>. Section <ref> we present our first solution the weighted ListMLE. The second more general approach is proposed in section  <ref> and the section <ref> describes the item-payoff and 
positional-gain model. The section <ref> provides experiments to show the efficacy of the proposed approach. Finally, section <ref> concludes the paper with a brief discussion on future directions. 




§ NOTATION

Vectors and matrices are denoted by bold-face lowercase and uppercase characters, respectively.  A list of size n is represented by the matrix 𝐗 = [𝐱_1, ⋯, 𝐱_n] ∈^d × n whose i^ th column 𝐱_i ∈^d is the feature vector of i^ th item in the list. 
Vectors of all ones and zeros of size n are denoted by 1_n and 0_n respectively. An identity matrix of size n × n is denoted by _n.  The set of all permutations of integers {1,⋯,n} is denoted by 𝒫_n. A particular permutation is denoted by Π = [π_1, ⋯, π_n] ∈𝒫_n where π_i denotes the position where the i^th item  in the list is placed. For example, π_2 = 1 implies that the second item is placed at the first position. For a given matrix ∈^d × n and Π∈_n,  _Π denotes a matrix whose columns are obtained by re-ordering columns of  as per Π. The function sort[x_1,⋯,x_n] returns the permutation denoting the positions of x_i's if they were placed in descending order.

	



§ PROBLEM FORMULATION


As discussed earlier, using the problem setup as shown in Figure <ref>, training data comprising of list of n items , the order in which it is shown Π∈_n, and the user assigned score s ∈^+ can be collected. Note that there is one single score for the entire list of items. We assume there is a probability distribution P_,Π,s over ^ d × n ×_n ×^+ from which we are given m i.i.d training examples as follows

    _N = {{(^(i), Π^(i)), s^(i)}_i=1^N  },

where ^(i)∈^d × n denotes the i^th list of items, Π^(i)∈_n is the order in which the items were shown to the user, and s^(i) is the corresponding score of the list. The goal is to use the training data to learn an ordering for the new list of items such that it maximizes the score. In light of the available training data, addressing this goal is particularly challenging because we do not have access to the order that maximizes score. Next we describe two approaches designed towards to achieve this goal. 



§ APPROACH 1: WEIGHTED LISTMLE

The main challenge in addressing the problem of ordering a list of items using the training data _N lies in the discrete combinatorial nature of input and output domains. As discussed earlier, the listwise learning-to-rank techniques have effectively addressed this challenge in a related but different setting. Our first approach builds upon a existing popular technique  ListMLE and extends it so that to our problem setting. We first briefly describe the ListMLE technique followed by details of our proposed extension to it. 



 §.§ ListMLE

The ListMLE approach is based on modeling the conditional probabilities of various permutations given the list of items <cit.>. Specifically, the conditional probability of a permutation Π∈𝒫_n given the list of items 𝐗∈ℝ^d × n is modeled by so called Plackett-Luce model as follows 
    P(Π | 𝐗; g) =  ∏_j=1^n  e^ g(𝐱_π_j) /∑_k=j^n e^ g(𝐱_π_k) ,

where g(·): ℝ^d →ℝ computes the score of each item and 𝐱_π_k denotes the feature vector of  π_k^th item in the list. Using training data _N the ListMLE entails solving the following maximum likelihood problem 

    min_g∑_i=1^N - log( P(Π^(i) | 𝐗^(i); g) ).

Note that in ListMLE, it is assumed that the output permutation Π is the desired permutation and the goal is to learn a mapping from the feature space to this output space. The learned mapping ĝ—the  solution of problem (<ref>)—is used to predict the order for a new list of items. For a new list of items 𝐗∈ℝ^d × n, first the predicted relevance scores {ĝ(𝐱_j)}_j=1^n are computed. These scores are then used to calculate the probabilities of various permutations using (<ref>). The inference procedure involves finding the maximum probability permutation, which can be efficiently implemented owing to the Plackett-Luce model in (<ref>) by sorting the predicted scores {ĝ(𝐱_j)}_j=1^n. Next, we present our approach which extends ListMLE to our problem setting.  





 §.§ Weighted ListMLE

As discussed earlier, our problem setup has a notion of input order. From equation (<ref>), it is clear that ListMLE  allows only one order per list that is assumed to be the best order in some sense. The input order in our approach may not necessarily be the best order as required by ListMLE since we want to figure out that out of all the possible permutations of the items which order corresponds to the best score. We propose weighted ListMLE to address this specific problem setting. Similar to ListMLE, we model the conditional probability of a order Π∈𝒫_n given the input list 𝐗∈ℝ^d × n by Plackett-Luce model in equation (<ref>). As our aim is to predict the order that maximizes the given metric, we weight the likelihood term for the given list of items and the order in which they were presented by the corresponding score s. Specifically, for the training data _N, the weighted ListMLE involves solving the following weighted maximum likelihood problem 

    min_g∑_i=1^N - s^(i)log( P(Π^(i) | 𝐗^(i); g) ).

In the above problem, the weights s^(i) bias the learning process such that the orders with higher score are given higher probabilities. The algorithm for solving the training problem (<ref>) can be shown to be a simple modification to existing training algorithm for ListMLE proposed in <cit.> by adding weights to the gradient computation.   
After learning the scoring function ĝ by solving the problem in (<ref>), it is used to find the permutation Π for a new list 𝐗 as follows 

    Π̂(𝐗) = max_Π∈𝒫_n  
    P(Π | 𝐗; ĝ).

Again, owing to the special structure of Plackett-Luce model, the Π̂(𝐗) can be obtained by simply sorting {  e^ĝ(𝐱_j) }_j=1^n in descending order as follows

    Π̂(𝐗) = sort[ exp(ĝ(𝐱_1)) ,⋯, exp(ĝ(𝐱_n))].

The weighted ListMLE can be reduced to ListMLE if the input order Π^(i) is chosen such that it is based on decreasing order of relevance of the items, i.e. the best order, and the corresponding scores is fixed to be constant (say s^(i) = 1 for all i). We extend existing ListMLE in a sense that the notion of input order can be accommodated. Weighted ListMLE can be construed as an attempt to extend the existing learning-to-rank to our setting while keeping the essential characteristics of ListMLE intact. Next, we present a more direct approach that handles our problem setup in more generality.






§ APPROACH 2: A MACHINE LEARNING BASED FRAMEWORK

Our ultimate goal it to learn a mapping that maximizes the score for the given list of items. Using machine learning techniques to learn such mapping would require training data in terms of list of items and the score maximizing order and existing learning-to-rank techniques can be applied. But the training data in our problem setup does not have this form that makes developing a machine learning approach to solve this problem challenging. However, using the training data _N in the form it is available to us it is possible to learn a mapping from (^d × n, _n ) to ^+ because the training data can be considered as noisy observations of such a mapping. Accordingly, we follow a two step approach: (1) learn a mapping that predicts score for the given list of items and order, (2) use the learned mapping to obtain the final order by maximizing the predicted order.  We learn the mapping f:(^d × n, _n ) →^+ by solving the following empirical risk minimization problem 

    f̂__N = min_ f ∈ ∑_i=1^N  (  s^(i) - f( ^(i), Π^(i))   )^2,

where  is the set of functions defined from (^d × n, _n ) to ^+. For a  new list of items ∈^d × n we infer the score maximizing ordering using the learned f̂__N in (<ref>) as follows

    Π̂() = max_Π∈_nf̂__N( , Π).

Above approach draws some parallel from multi-class classification problems where the training data is first used to accurately predict the probability of various classes, and the classifiers output is obtained by maximizing the predicted probability. Here, we first use the training data to fit a function that accurately predict the score for given list of items and input order, and then, use the learned mapping to predict the final order by maximizing the predicted score. The choice of function class  is critical to the feasibility of the approach described above as it involves combinatorial input and output domain. Next we discuss various issues that govern the choice of function class .



  
Choosing the function class : As the inference problem in (<ref>) involves optimization over set of permutations _n, its computational complexity is (n!) = (n^n) making it computationally prohibitive even for modest values of n.  Therefore, the first requirement on the function class  is to make the corresponding inference problem in (<ref>) feasible. In addition to the inference complexity, note that for the fixed value of list of items , the function f(, Π) can take n! different values by choosing different Π∈_n. Therefore, the second requirement on the function class  is that it should prevent over-fitting and the estimate f̂__N should have reasonable variance with practically feasible number of training data points. Both these requirements can be handled if the function class  is simple. For these purposes, we propose the class of functions that can be decomposed as follows 

    f(,Π) = ∑_i=1^n h( _i, π_i),

where h ∈ and  is some class of functions defined from ( ^d, {1,⋯,n}) to ^+. The specific structure considered in (<ref>) is simple because the overall score predicted by these functions depends on the item feature vector and the locations it appears in Π. Further, note that these functions still take n! values for a given  by choosing different Π∈_n. However, each of these values is sum of some n entries chosen from a scoring matrix _h() defined as

    _h() = [ h(_1,1)       ⋯ h(_1,n);       ⋮       ⋯       ⋮; h(_n,1)       ⋯ h(_n,n) ].

For a given order Π, all the terms in the summation in (<ref>) can be obtained from the entries of the scoring matrix _h(). This essentially implies that the functions following the decomposition in (<ref>) have inherent low dimensional structure. 



  
Training with :
The training with the  in (<ref>), the empirical risk minimization problem in (<ref>) reduces to 

    ĥ__N = min_ h ∈ ∑_i=1^N  (  s^(i) -  ∑_j=1^n h(_j^(i),π_j^(i))    )^2.

The actual complexity of above training problem will depend on the specific choice of the function class . This issue will be discussed in greater details later in this paper when we consider a specific example of .




  
Inference with :
The inference problem in (<ref>) reduces to the following problem

    Π̂() = max_Π∈_n∑_i=1^n ĥ__N( _i, π_i ).

Further, observing that Π is a valid permutation, i.e., at one location only one item is placed, we do a change of variable from permutation Π∈_n to a permutation matrix ∈^n × n. The permutation matrix  is such that its entries are either 1 or 0 and there is exactly one non-zero entry in each column and row. The rows of  can be obtained for a given Π in such a manner that if the i^th item goes to j^th location  P_i,j = 1. This implies that there is one to one mapping from Π to  and the objective in problem (<ref>) can be written in terms of  as follows 

    ∑_i=1^n ĥ__N( _i, π_i ) = ∑_i=1^n ∑_j=1^n P_ijĥ__N( _i, j ).

Next we use the notion of scoring matrix introduced in (<ref>) and we introduce analogous scoring matrix _ĥ__N() whose (i,j)^th entry is ĥ__N( _i, j ). With this the problem the inference problem in (<ref>) can be converted to an equivalent problem as follows

    ∈^n × nmin      Tr(  𝐏_ĥ__N()  ) 
       subject to       ∑_i=1^n P_ij = 1,  ∀ j,  ∑_j=1^n P_ij = 1   ∀ i,
                P_ij∈{0,1} ∀ i,j,

where Tr( · ) represents sum of diagonal entries of a matrix. Problem (<ref>) is an instance of the classical linear sum assignment problem that due to the total unimodularity of the constraints can be efficiently solved by relaxing it to the following linear program <cit.>

    ∈^n × nmin      Tr(  𝐏_ĥ__N()  ) 
       subject to       ∑_i=1^n P_ij = 1,  ∀ j,  ∑_j=1^n P_ij = 1   ∀ i,
                P_ij≥ 0  ∀ i,j.

Above inference problem is a linear program of n^2 variables that can be solved in polynomial time as compared to the original inference problem in (<ref>) whose complexity without our choice of simpler function class  could be (n^n) in worst case. Recently, a fast greedy algorithm with provable 1/2-optimal solution with a worst-case runtime of (n^2) was used in <cit.> for online constrained ranking problems. 











 


§ AN INSTANCE OF : THE ITEM-PAYOFF AND POSITIONAL-GAIN MODEL

Here we propose a specific instance of the class  that follows the decomposition in (<ref>). The proposed model utilizes the notions of positional-gains and item-payoffs. For the given list of items , the item-payoff vector whose i^th entry denotes the payoff associated with i^th item is modeled as follows

    exp( ^T^* ) =  [ exp( 𝐱_1^T  𝐯^* ), ⋯ ,exp( 𝐱_n^T  𝐯^* ) ]^T

where 𝐯^* ∈^d is a fixed ground truth weight vector. 
The positional-gain is the property of position and it is defined by the gain vector 𝐠^* ∈ℝ^n whose  i^th component g_i denotes the gain associated with i^th position. With this for the given list of items 𝐗 and order Π∈𝒫_n, the score is calculated as follows 

    f(Π,𝐗) = (^*)^T exp( ^T_Π^* ),

where _Π is the matrix whose columns are obtained by ordering columns of  as per Π. The function in (<ref>) is an instance of the function class defined in (<ref>) with h(_i,π_i) = g_π_i^*exp(_i^T^*). A similar model was proposed in <cit.> in context of explore and exploit in top-N recommender systems however it focused on modeling the item relevance under the assumption that first position is more important than second and so on. In contrast, we do not have such an assumption in our problem setup.



  
Training: As h(_i,π_i) =  g_π_i^*exp(_i^T^*), the function class  is parametrized by the positional-gain vector  and the weight vector . With this the empirical risk minimization problem in (<ref>) reduces to

    min_∈^d, ∈^n∑_i=1^N ( s^(i) -   exp( ^T ^(i)_Π^(i))  )^2.

The above problem suffers from scaling ambiguity due the product term exp( ^T ^(i)_Π^(i)). In addition, this term increases exponentially with scaling of  which results in numerical overflow issues. For these purposes instead of solving problem (<ref>) we solve the following modified problem for training 

    ∈^d, ∈^nmin∑_i=1^N ( s^(i) -   exp( ^T ^(i)_Π^(i))  )^2 +  λ_2^2 
       subject to  _2 ≤ 1.

where λ>0 is a regularization parameter. Even though we have addressed the issue of scaling ambiguity the problem in (<ref>) is still jointly non-convex in  and . However, for a fixed  the problem is convex in 
 and similarly, for a fixed  as well the problem is convex in . Based on this we propose an alternating minimization based algorithm for approximately solving problem (<ref>). Starting with initial ^(0) = 1_n/√(n) we alternatively minimize with respect to  and  until convergence. The final procedure is detailed in Algorithm <ref>.

The  update step in this algorithm is a standard ℓ_2 regularized least squares problem which can solved in closed form and the  update step is a constrained convex program which can be solved by a projected gradient descent approach shown in Algorithm <ref>. 





  
Inference: After obtaining , from Algorithm <ref>, they can be used to obtain an estimate for the score for the given list of items  and input order Π as follows

    f̂(Π,) = ( )^T exp(  _Π^T ).

For inferring the order that maximizes the predicted score we first use the fact that for the item-payoff and positional-gain model, h(_i,π_i) = ĝ_π_iexp( _i^T ) and calculate the scoring matrix followed by solving the linear program in (<ref>). However, owing to the linear structure of the positional-gain and item-payoff model the score maximizing order simply corresponds to first sorting the estimated payoffs {exp( _i^T ) }_i=1^n for each item and then putting the item with largest estimated payoff at the position with largest estimated gain and so on. 





§ EXPERIMENTS

We evaluate our approach on the synthetic as well as real data.


 §.§ Synthetic Data



For the synthetic experiments, we fixed the list size as n=5 and dimensionality of feature vector as d=10. The mean vectors {μ_i }_i=1^n for each item were generated once at start of the experiment such that their components are i.i.d. random variable uniformly distributed in the interval [0,1]. A random list of items is generated such that the feature vector for i^th item in the list follows a multivariate Gaussian distribution 𝒩( μ_i,  𝐈_n/10 ). Further, using a randomly generated vector ^* ∈^n generated once at start of the experiment the score for given input order Π and list of items 
was generated as follows


    s(Π,) = (^*)^T [ exp( ^T_Π^* )/1_n^Texp( ^T_Π^* ) ],

where ^* ∈^n is a fixed positional-gain vector. This serves as a ground truth model for calculating the score. Note this score calculation does not exactly follow the item-payoff positional gain model.

For training N=1000 lists were randomly generated and input order for each list was chosen uniformly at random from the set 𝒫_n and corresponding score was calculated using (<ref>) to obtain the training data {(( 𝐗^(i), Π^(i)),  s^(i)) }_i=1^N. 
For training weighted ListMLE we fixed the function g() = ^T where ∈^d,  and solved (<ref>) to obtain . With linear g() the problem in (<ref>) can be shown to be a convex program that can be efficiently solved by gradient descent algorithm. For a new list the final order was obtained using (<ref>) with  ĝ()  = ^T. For the second approach we used training data along with Algorithm <ref> to obtain  and . For a new list these vectors were used to obtain the final order by maximizing the predicted score in equation (<ref>).


We compare our approaches to  ListMLE that requires access to desired order, i.e., the order that maximizes the score in (<ref>). However, this is not possible in above experimental setting. Typical ListMLE would use an order obtained by sorting the per-item relevance scores. Here, we provided the relevance score vector for items in the list as 𝐲^(i) = ( 𝐗^(i))^T 𝐯^* whose were components sorted to obtain the training data as {( 𝐗^(i), Π^(i)_2 = sort(𝐲^(i))  )}. Here too, we fixed g() = ^T and solved (3) to obtain . For a new list of items  was used to predict the final order by  permutation by maximizing the probability in (<ref>).
	 
For testing, 500 new lists of items were randomly generated and for each list in the test data, orders predicted by all the approaches were obtained and respective scores were calculated using the ground truth model in (<ref>). We repeated the experiments for three different positional-gain vectors and the average scores with various approaches are shown in Table <ref>. The 1^ st row represents the case when all the positions have same gain, i.e., this implies there is no positional preference and as expected we see that all approaches perform the same. The 2^ nd row represent the case with positional-gain vector is skewed so that only third and fourth position are important whereas the 3^ rd row represents a less skewed position gains.  We observe that our approached performs better than ListMLE and the second approach performs the best in both these cases. The superior performance of our approaches can be attributed to the fact that they model input order explicitly. 

The main reason for experiments on synthetic data was to understand the effectiveness of proposed solutions in an ideal setting where input order effect can be precisely controlled. Using various positional gain vectors we were able to show that empirically our proposed approaches are successful as compared to the traditional ListMLE.
We would also like to acknowledge that there may be many other ways of  generating the score s(𝐗, Π) but for the purposes of demonstrating the main idea we choose the specific model in (<ref>). Our main goal here is to highlight a setting where the desired order is not available during training and sorting according to the relevance scores may not be the best thing. We note that our main critique is not that of a particular learning-to-rank technique but its problem setting and ListMLE just serves as an popular representative example of that problem setting.  Next, we demonstrate the effectiveness of our approaches in a real-life setting.



 §.§ Real data





For the experiments with real data we used data from Yahoo! (www.yahoo.com) that is predominantly a news website; the items in this setup are the news articles. Each article can be related to a few content-categories out of a total of 405 categories internally defined by Yahoo!. For instance, an article can have a score of 0.5 towards the category politics along with a score of 0.1 towards entertainment. Association of articles to these categories is part of Yahoo's content understanding platform whose details are out of the scope of this paper. But as a outcome of this content ingestion and understanding pipeline, each article is represented by a feature vector in d = 405 dimensional space. Each user is served a list of articles and the order in which these articles are presented is captured by our training data. The size of list was fixed as n=3. The data was collected using logs obtained over one day of website usage. From the resulting logs, we obtained the list of news articles and their feature representations, the order in which they were presented, and the corresponding dwell time or average time the user spent on the entire list. The metric of interest here is the dwell time.  After preprocessing the data we obtained a total of 4950 data points out of which we used 4000 examples for training and rest for testing. 

We note that the dwell time is affected by the relative position of news articles with respect to each other. In this particular real life application there is no clear notion of per item relevance rather we just have the dwell time which is a function of the list of news articles and the order in which they were shown on the website. This is an example where traditional learning-to-rank approaches are not applicable. We, however, apply the ListMLE where the training data for ListMLE was fixed as the list of news articles and order in which they were shown using the existing ranking mechanism. In this manner ListMLE learns to predict order as per the current ranking system on the news website.    

We note here that accessing the quality of ordering given by various approaches is a bit tricky because in the test set the dwell times corresponding to all the permutations of given list of items is not available. In other words, we only have partial ground truth order available to us. In order to deal with this, we first found the various orders that available for a the given list of news article in the test data and noted their dwell times. We then ranked these orders for given list of items based on their dwell times. For the same list of news articles we calculated the predicted scores for these orders using item-payoff and positional gain model, and probabilities in case of weighted ListMLE and ListMLE.   Finally, the Normalized discounted cumulative gain (NDCG) score between the ranking of orders obtained by decreasing order of dwell time from test data and the ranking of orders obtained by different approaches was calculated. The goal here is to check whether our approaches gives higher score to the orders with higher dwell time.  We also calculated the average dwell for the top order (among the orders available in the test data) predicted by all the approaches.
The final results are shown in Table <ref>. The reported results averaged over 10 random splitting of data in training and test sets. We observe that our approach performs better than ListMLE in terms of average NDCG and average dwell times for the top-1 order predicted by our approaches.  The item-payoff and positional-gain model based approach performs the best. These results show that our approach predicts order that correlates more with the order as per the dwell times.  
The relative performances of these three approaches can be understood based on how they model the input-order. ListMLE that does not model the input order performs the worst followed by weighted ListMLE that can construed an minor modification to ListMLE whereas the item-payoff and positional-gain approach explicitly models the input-order and performs the best. 









§ CONCLUSION AND FUTURE DIRECTIONS
 

In this paper, we investigate the problem of ranking list of items to maximize a given metric of interest when the best or desired order is not provided during the training. Following the learning-to-rank based 
route to solve this problem we reveal a new problem setup that is usually not considered in traditional learning-to-rank literature. We proposed two approaches: (1) weighted ListMLE and (2) a generic machine learning framework and item-payoff and positional-gain as an instance of the generic framework. The effectiveness of the proposed approaches was demonstrated on simulated as well as real-life setting of ranking news articles for increased dwell time. 

Future directions for this work include establishing the sample complexity bounds and generalization guarantees for the proposed approaches. Exploring more complex models than item-payoff and positional-gain model is yet another interesting direction for future research. 












 
IEEEbib


