user: text: Write a concise one-sentence TLDR summary of the scientific paper content below.

Title: Seq2Slate: Re-ranking and Slate Optimization with RNNs

Paper content:
Ranking is a central task in machine learning and information retrieval.
In this task, it is especially important to present the user with a slate of items that is appealing as a whole.
This in turn requires taking into account interactions between items, since intuitively, placing an item on the slate affects the decision of which other items should be chosen alongside it.
In this work, we propose a sequence-to-sequence model for ranking called seq2slate.
At each step, the model predicts the next item to place on the slate given the items already chosen.
The recurrent nature of the model allows complex dependencies between items to be captured directly in a flexible and scalable way.
We show how to learn the model end-to-end from weak supervision in the form of easily obtained click-through data.
We further demonstrate the usefulness of our approach in experiments on standard ranking benchmarks as well as in a real-world recommendation system.
Ranking a set of candidate items is a central task in machine learning and information retrieval.
Many existing ranking systems are based on pointwise estimators, where the model assigns a score to each item in a candidate set and the resulting slate is obtained by sorting the list according to item scores ).
Such models are usually trained from click-through data to optimize an appropriate loss function BID17 .
This simple approach is computationally attractive as it only requires a sort operation over the candidate set at test (or serving) time, and can therefore scale to large problems.
On the other hand, in terms of modeling, pointwise rankers cannot easily express dependencies between ranked items.
In particular, the score of an item (e.g., its probability of being clicked) often depends on the other items in the slate and their joint placement.
Such interactions between items can be especially dominant in the common case where display area is limited or when strong position bias is present, so that only a few highly ranked items get the user's attention.
In this case it may be preferable, for example, to present a diverse set of items at the top positions of the slate in order to cover a wider range of user interests.
A significant amount of work on learning-to-rank does consider interactions between ranked items when training the model.
In pairwise approaches a classifier is trained to determine which item should be ranked first within a pair of items (e.g., BID13 BID17 BID6 .
Similarly, in listwise approaches the loss depends on the full permutation of items (e.g., BID7 BID47 .
Although these losses consider inter-item dependencies, the ranking function itself is pointwise, so at inference time the model still assigns a score to each item which does not depend on scores of other items.
There has been some work on trying to capture interactions between items in the ranking scores themselves (e.g., BID29 BID22 BID49 BID32 BID8 .
Such approaches can, for example, encourage a pair of items to appear next to (or far from) each other in the resulting ranking.
Approaches of this type often assume that the relationship between items takes a simple form (e.g., submodular) in order to obtain tractable inference and learning algorithms.
Unfortunately, this comes at the expense of the model's expressive power.
In this paper, we present a general, scalable approach to ranking, which naturally accounts for high-order interactions.
In particular, we apply a sequence-to-sequence (seq2seq) model BID35 to the ranking task, where the input is the list of candidate items and the output is the resulting ordering.
Since the output sequence corresponds to ranked items on the slate, we call this model sequence-to-slate (seq2slate).
The order in which the input is processed can significantly affect the performance of such models BID39 .
For this reason, we often assume the availability of a base (or "production") ranker with which the input sequence is ordered (e.g., a simple pointwise method that ignores the interactions we seek to model), and view the output of our model as a re-ranking of the items.To address the seq2seq problem, we build on the recent success of recurrent neural networks (RNNs) in a wide range of applications (e.g., BID35 .
This allows us to use a deep model to capture rich dependencies between ranked items, while keeping the computational cost of inference manageable.
More specifically, we use pointer networks, which are seq2seq models with an attention mechanism for pointing at positions in the input BID38 .
We show how to train the network end-to-end to directly optimize several commonly used ranking measures.
To this end, we adapt RNN training to use weak supervision in the form of click-through data obtained from logs, instead of relying on ground-truth rankings, which are much more expensive to obtain.
Finally, we demonstrate the usefulness of the proposed approach in a number of learning-to-rank benchmarks and in a large-scale, real-world recommendeation system.
We presented a novel seq2slate approach to ranking sets of items.
We found the formalism of pointer-networks particularly suitable for this setting.
We addressed the challenge of training the model from weak user feedback to improve the ranking quality.
Our experiments show that the proposed approach is highly scalable and can deliver significant improvements in ranking results.
Our work can be extended in several directions.
In terms of architecture, we aim to explore the Transformer network BID36 in place of the RNN.
Several variants can potentially improve the performance of our model, including beam-search inference BID44 , and training with Actor-Critic BID2 or SeaRNN BID21 ) and it will be interesting to study their performance in the ranking setting.
Finally, an interesting future work direction will be to study off-policy correction BID16 Since the terms are continuous (and smooth) in S for all j and π <j , so is the entire function.

assistant: text: A pointer network architecture for re-ranking items, learned from click-through logs.