Scalable Bayesian Preference Learning for Crowds

We propose a scalable Bayesian preference learning method for jointly predicting the preferences of individuals as well as the consensus of a crowd from pairwise labels. Peoples' opinions often differ greatly, making it difficult to predict their preferences from small amounts of personal data. Individual biases also make it harder to infer the consensus of a crowd when there are few labels per item. We address these challenges by combining matrix factorisation with Gaussian processes, using a Bayesian approach to account for uncertainty arising from noisy and sparse data. Our method exploits input features, such as text embeddings and user metadata, to predict preferences for new items and users that are not in the training set. As previous solutions based on Gaussian processes do not scale to large numbers of users, items or pairwise labels, we propose a stochastic variational inference approach that limits computational and memory costs. Our experiments on a recommendation task show that our method is competitive with previous approaches despite our scalable inference approximation. We demonstrate the method's scalability on a natural language processing task with thousands of users and items, and show improvements over the state of the art on this task. We make our software publicly available for future work.


Introduction
Preference learning involves comparing a set of alternatives according to a particular quality (Fürnkranz and Hüllermeier 2010), which often leads to a divergence of opinion between people. For example, in argument mining, a sub-field of natural language processing (NLP), one goal is to rank arguments by their convincingness (Habernal and Gurevych 2016). Whether a particular argument is convincing or not depends on the reader's point of view and prior knowledge (Lukin et al. 2017). Similarly, personal preferences affect recommender systems, which often perform better if they tailor recommendations to a specific user (Resnick and Varian 1997). Disagreements also occur when preference annotations are acquired from multiple annotators, for example, using crowdsourcing, and are often mitigated by redundant labelling (Snow et al. 2008;Banerji et al. 2010). Therefore, we require preference learning methods that can account for differences of opinion to (1) predict personal preferences for members of a crowd and (2) infer a consensus given observations from multiple users. For both tasks, our goal is to rank items or choose the preferred item from any given pair.
Recommender systems often predict a user's preferences via collaborative filtering, which overcomes data sparsity by exploiting similarities between the preferences of different users (Resnick and Varian 1997;Koren et al. 2009). Many recommender systems are based on matrix factorisation techniques that are trained using observations of numerical ratings. However, different annotators often disagree over numerical annotations and can label inconsistently over time (Ovadia 2004;Yannakakis and Hallam 2011), as annotators may interpret the values differently: a score of 4/5, say, from one annotator may be equivalent to 3/5 from another. The problem is avoided by pairwise labelling, in which the annotator selects their preferred item from a pair, which can be quicker (Kendall 1948;Kingsley and Brown 2010;Yang and Chen 2011), more accurate (Kiritchenko and Mohammad 2017), and facilitates the total sorting of items, as it avoids two items having the same value.
Pairwise labels provided by a crowd or extracted from user logs (Joachims 2002) are often noisy and sparse, i.e., many items or users have few or no labels. This motivates a Bayesian treatment, which has been shown to benefit matrix factorisation (Salakhutdinov and Mnih 2008) and preference learning . Some previous Bayesian methods for preference learning use Gaussian processes (GPs) to account for input features of items or users (Chu and Ghahramani 2005;Houlsby et al. 2012;Khan et al. 2014). These are features that can be extracted from content or metadata, such as embeddings (Mikolov et al. 2013;Devlin et al. 2019), which are commonly used by NLP methods to represent words or documents using a numerical vector. Input features allow the model to extrapolate to new items or users and mitigate labelling errors (Felt et al. 2016). However, previous Bayesian preference learning methods that account for input features using GPs do not scale to large numbers of items, users, or pairwise labels, as their computational and memory requirements grow with the size of the dataset.
In this paper, we propose a scalable Bayesian approach to pairwise preference learning with large numbers of users or annotators. Our method, crowdGPPL, jointly models personal preferences and the consensus of a crowd through a combination of matrix factorisation and Gaussian processes. We propose a stochastic variational inference (SVI) scheme (Hoffman et al. 2013) that scales to extremely large datasets, as its memory complexity and the time complexity of each iteration are fixed independently of the size of the dataset. Our new approach opens the door to novel applications involving very large numbers of users, items and pairwise labels, that would previously have exceeded computational or memory resources and were difficult to parallelise. We evaluate the method empirically on two realworld datasets to demonstrate the scalability of our approach, and its ability to predict both personal preferences and a consensus given preferences from thousands of users. Our results improve performance over the previous state-of-the-art (Simpson and Gurevych 2018) on a crowdsourced argumentation dataset, and show that modelling personal preferences improves predictions of the consensus, and vice versa.

Related Work
To obtain a ranking from pairwise labels, many preference learning methods model the user's choices as a random function of the latent utility of the items. Inferring the utilities of items allows us to rank them, estimate numerical ratings and predict pairwise labels. Many popular instances of this approach, known as a random utility model (Thurstone 1927), are variants of the Bradley-Terry (BT) model (Bradley and Terry 1952;Plackett 1975;Luce 1959), which assumes a logistic likelihood, or the Thurstone-Mosteller model (Thurstone 1927;Mosteller 1951), which assumes a probit likelihood. Recent work on the BT model has developed computationally efficient active learning, but does not consider input features (Li et al. 2018). Another commonly-used ranking method, SVM-rank (Joachims 2002), predicts pairwise labels from input features without a random utility model, so cannot predict utilities. Gaussian process preference learning (GPPL) provides a Bayesian treatment of the random utility model, using input features to predict the utilities of test items and share information between similar items (Chu and Ghahramani 2005). As GPPL can only predict the preferences of a single user, we introduce a new, scalable approach to model individuals in a crowd.
Previous work on preference learning from crowdsourced data treats disagreements as annotation errors and infers only the consensus, rather than modelling personal preferences. For instance, Chen et al. (2013) and Wang et al. (2016) tackle annotator disagreement using Bayesian approaches that learn the labelling accuracy of each worker. Recently, Pan et al. (2018) and Han et al. (2018) introduced scalable methods that extend this idea from pairwise labels to noisy k-ary preferences, i.e., totally-ordered subsets of k items. Fu et al. (2016) improved SVM-rank by identifying outliers in crowdsourced data that correspond to probable errors, while Uchida et al. (2017) extend SVM-rank to account for different levels of confidence in each pairwise annotation expressed by the annotators. However, while these approaches differentiate the level of noise for each annotator, they ignore labelling bias as the differences between users are not random but depend on personal preferences toward particular items. With small numbers of labels per item, these biases may reduce the accuracy of the estimated consensus. Furthermore, previous aggregation methods for crowdsourced preferences do not consider item features, so cannot predict the utility of test items Wang et al. 2016;Han et al. 2018;Pan et al. 2018;Li et al. 2018). Our approach goes beyond these methods by predicting personal preferences and incorporating input features.
A number of methods use matrix factorisation to predict personal preferences from pairwise labels, including Yi et al. (2013), who focus on small numbers of pairs per user, and Salimans et al. (2012), who apply Bayesian matrix factorisation to handle sparse data. Matrix factorisation represents observed ratings in a user-item matrix, which it decomposes into two matrices of lower rank than the user-item matrix, one corresponding to users and one to items. Users with similar ratings have similar columns in the user matrix, where each entry is a weight over a latent rating. By multiplying the low-dimensional representations, we can predict ratings for unseen user-item pairs. Kim et al. (2014) use a simplification that assumes that each user's preferences depend on only one latent ranking. However, previous works combining matrix factorisation with pairwise preference labels do not account for input features. This contrasts with work on matrix factorisation with side information, where the ratings or preferences as well as input features are directly observed, including recent neural network approaches (Volkovs et al. 2017), Bayesian approaches that concatenate input feature vectors with the low-dimensional factored representations (Porteous et al. 2010), and GP-based methods (Adams et al. 2010). Besides providing a Bayesian method for matrix factorisation with both input features and pairwise labels, this paper introduces a much more scalable inference method for a GP-based model.
GPs were previously used for personal preference prediction by Guo et al. (2010), who propose a GP over the joint feature space of users and items. Since this scales cubically in the number of users, Abbasnejad et al. (2013) propose to cluster users into behavioural groups, but distinct clusters do not allow for collaborative learning between users whose preferences only partially overlap, e.g. when two users both like one genre of music, but have different preferences over other genres. Khan et al. (2014) instead learn a GP for each user, then add a matrix factorisation term that performs collaborative filtering. However, this approach does not model the relationship between input features and the low-rank matrices, unlike Lawrence and Urtasun (2009) who place GP priors over latent ratings. Neither of these last two methods are fully Bayesian as the users' weights are optimised rather than marginalised. An alternative is the collaborative GP (collabGP) (Houlsby et al. 2012), which places GP priors over user weights and latent factors, thereby exploiting input features for both users and items. However, unlike our approach, collabGP predicts only pairwise labels, not the utilities of items, which are useful for rating and ranking, and can only be trained using pairwise labels, even if observations of the utilities are available. Furthermore, existing GP-based approaches suffer from scalability issues and none of the previous methods jointly model the consensus as well as personal preferences in a fully-Bayesian manner.
Established methods for GP inference with non-Gaussian likelihoods, such as the Laplace approximation and expectation propagation (Rasmussen and Williams 2006), have time complexity O(N 3 ) with N data points and memory complexity O(N 2 ). For collabGP, Houlsby et al. (2012) use a sparse generalized fully independent training conditional (GFITC) approximation (Snelson and Ghahramani 2006) to reduce time complexity to O(PM 2 + U M 2 ) and memory complexity to O(PM +U M), where P is the number of pairwise labels, M P is a fixed number of inducing points, and U is the number of users. However, this is not sufficiently scalable for very large numbers of users or pairs, due to increasing memory consumption and optimisation steps that cannot be distributed. Recent work on distributing and parallelising Bayesian matrix factorisation is not easily applicable to models that incorporate GPs (Ahn et al. 2015;Saha et al. 2015;Vander Aa et al. 2017;Chen et al. 2018).
To handle large numbers of pairwise labels, Khan et al. (2014) subsample the data rather than learning from the complete training set. An alternative is stochastic variational inference (SVI) (Hoffman et al. 2013), which optimises a posterior approximation using a different subsample of training data at each iteration, meaning it learns from all training data over multiple iterations while limiting costs per iteration. SVI has been applied to GP regression (Hensman et al. 2013) and classification (Hensman et al. 2015), further improving scalability over earlier sparse approximations. Nguyen and Bonilla (2014) introduce SVI for multi-output GPs, where each output is a weighted combination of latent functions. They apply their method to capture dependencies between regression tasks, treating the weights for the latent functions as hyperparameters. In this paper, we introduce a Bayesian treatment of the weights and apply SVI instead to preference learning. An SVI method for GPPL was previously introduced by Simpson and Gurevych (2018), which we detail in Section 4. However, as GPPL does not consider the individual preferences of users in a crowd, we propose a new model, crowdGPPL, which jointly models personal preferences and the crowd consensus using a combination of Gaussian processes and Bayesian matrix factorisation.

Bayesian Preference Learning for Crowds
We assume that a pair of items, a and b, have utilities f (x a ) and f (x b ), which represent their value to a user, and that f : R D → R is a function of item features, where x a and x b are vectors of length D containing the features of items a and b, respectively. If f (x a ) > f (x b ), then a is preferred to b (written a b). The outcome of a comparison between a and b is a pairwise label, y(a, b). Assuming that pairwise labels never contain errors, then y(a, b) = 1 if a b and 0 otherwise. Given knowledge of f , we can compute the utilities of items in a test set given their features, and the outcomes of pairwise comparisons. Thurstone (1927) proposed the random utility model, which relaxes the assumption that pairwise labels, y(a, b), are always consistent with the ordering of f (x a ) and f (x b ). Under the random utility model, the likelihood p(y(a, b) = 1) increases as f a − f b increases, i.e., as the utility of item a increases relative to the utility of item b. This reflects the greater consistency in a user's choices when their preferences are stronger, while accommodating labelling errors or variations in a user's choices over time. In the Thurstone-Mosteller model, noise in the observations is explained by a Gaussian-distributed noise term, δ ∼ N (0, σ 2 ): Integrating out the unknown values of δ a and δ b gives: , and Φ is the cumulative distribution function of the standard normal distribution, meaning that Φ(z) is a probit likelihood.2 This likelihood is also used by Chu and Ghahramani (2005) for Gaussian process preference learning (GPPL), but here we simplify the formulation by assuming that σ 2 = 0.5, which leads to z having a denominator of . Instead, we model varying degrees of noise in the pairwise labels by scaling f itself, as we describe in the next section.
In practice, f (x a ) and f (x b ) must be inferred from pairwise training labels, y, to obtain a posterior distribution over their values. If this posterior is a multivariate Gaussian distribution, then the probit likelihood allows us to analytically marginalise f (x a ) and f (x b ) to obtain the probability of a pairwise label: wheref a andf b are the means and C is the posterior covariance matrix of the multivariate Gaussian over f (x a ) and f (x b ). Unlike other choices for the likelihood, such as a sigmoid, the probit allows us to compute the posterior over a pairwise label without further approximation, hence we assume this pairwise label likelihood for our proposed preference learning model.

GPPL for Single User Preference Learning
We can model the preferences of a single user by assuming a Gaussian process prior over the user's utility function, f ∼ GP(0, k θ /s), where k θ is a kernel function with hyperparameters θ and s is an inverse scale parameter. The kernel function takes numerical item features as inputs and determines the covariance between values of f for different items. The choice of kernel function and its hyperparameters controls the shape and smoothness of the function across the feature space and is often treated as a model selection problem. Kernel functions suitable for a wide range of tasks include the squared exponential and the Matérn (Rasmussen and Williams 2006), which both make minimal assumptions but assign higher covariance to items with similar feature values. We use k θ to compute a covariance matrix K θ , between a set of N observed items with features X = {x 1 , ..., x N }.
Here we extend the original definition of GPPL (Chu and Ghahramani 2005), by introducing the inverse scale, s, which is drawn from a gamma prior, s ∼ G(α 0 , β 0 ), with shape α 0 and scale β 0 . The value of 1/s determines the variance of f , and therefore the magnitude of differences between f (x a ) and f (x b ) for items a and b. This in turn affects the level of certainty in the pairwise label likelihood as per Equation 2.
Given a set of P pairwise labels, y = {y 1 , ..., y P }, where y p = y(a p , b p ) is the preference label for items a p and b p , we can write the joint distribution over all variables as follows: } is a vector containing the utilities of the N items referred to by y, and p(y p | f ) = Φ z p is the pairwise likelihood (Equation 2).

Crowd Preference Learning
To predict the preferences of individuals in a crowd, we could use an independent GPPL model for each user. However, by modelling all users jointly, we can exploit correlations between their interests to improve predictions when preference data is sparse, and reduce the memory cost of storing separate models. Correlations between users can arise from common interests over certain subsets of items, such as in one particular genre in a book recommendation task. Identifying such correlations helps to predict preferences from fewer observations and is the core idea of collaborative filtering (Resnick and Varian 1997) and matrix factorisation (Koren et al. 2009). As well as individual preferences, we wish to predict the consensus by aggregating preference labels from multiple users. Individual biases of different users may affect consensus predictions, particularly when data for certain items comes from a small subset of users. The consensus could also help predict preferences of users with little or no data by favouring popular items and avoiding generally poor items. We therefore propose crowdGPPL, which jointly models the preferences of individual users as well as the underlying consensus of the crowd. Unlike previous methods for inferring the consensus, such as CrowdBT ), we do not treat differences between users as simply the result of labelling errors, but also account for their subjective biases towards particular items.
For crowdGPPL, we represent utilities in a matrix, F ∈ R N ×U , with U columns corresponding to users. Within F, each entry F a, j = f (x a , u j ) is the utility for item a for user j with user features u j . We assume that F = V T W + t1 T is the product of two low-rank matrices plus a column vector of consensus utilities, t ∈ R N , where W ∈ R C×U is a latent representation of the users, V ∈ R C×N is a latent representation of the items, C is the number of latent components, i.e., the dimension of the latent representations, and 1 is a column vector of ones of length U. The column v .,a of V , and the column w ., j of W , are latent vector representations of item a and user j, c is an inverse function scale, and θ are kernel hyperparameters. The consensus utilities, t = {t(x 1 ), ..., t(x N )}, are values of a consensus utility function over item features, t ∼ GP(0, k θ /s (t) ), which is shared across all users, with inverse scale c ), of user features, u j , with inverse scale s (w) c and kernel hyperparameters η. Therefore, each utility in F can be written as a weighted sum over the latent components: where u j are the features of user j and x a are the features of item a. Each latent component corresponds to a utility function for certain items, which is shared by a subset of users to differing degrees. For example, in the case of book recommendation, c could relate to science fiction novels, v c to a ranking over them, and w c to the degree of agreement of users with that ranking. The individual preferences of each user j deviate from a consensus across users, t, . This allows us to subtract the effect of individual biases when inferring the consensus utilities. The consensus can also help when inferring personal preferences for new combinations of users and items that are very different to those in the training data by accounting for any objective or widespread appeal that an item may have.
Although the model assumes a fixed number of components, C, the GP priors over w c and v c act as shrinkage or ARD priors that favour values close to zero (MacKay 1995; Psorakis et al. 2011). Components that are not required to explain the data will have posterior expectations and scales 1/s (v) and 1/s (w) approaching zero. Therefore, it is not necessary to optimise the value of C by hand, providing a sufficiently large number is chosen.
Equation 5 is similar to cross-task crowdsourcing (Mo et al. 2013), which uses matrix factorisation to model annotator performance in different tasks, where t corresponds to the objective difficulty of a task. However, unlike crowdGPPL, they do not use GPs to model the factors, nor apply the approach to preference learning. For preference learning, collabGP (Houlsby et al. 2012) is a related model that excludes the consensus and uses values in v c to represent pairs rather than individual items, so does not infer item ratings. It also omits scale parameters for the GPs that encourage shrinkage when C is larger than required.
We combine the matrix factorisation method with the preference likelihood of Equation 2 to obtain the joint preference model for multiple users, crowdGPPL: where index p refers to a user and a pair of items, {u p , a p , b p }, U is the set of feature vectors for all users, K θ is the prior covariance for the items as in GPPL, and L η is the prior covariance for the users computed using k η .

Scalable Inference
Given a set of pairwise training labels, y, we aim to find the posterior over the matrix F * = V * T W * of utilities for test items and test users, and the posterior over consensus utilities for test items, t * . The non-Gaussian likelihood (Equation 2) makes exact inference intractable, hence previous work uses the Laplace approximation for GPPL (Chu and Ghahramani 2005) or combines expectation propagation (EP) with variational Bayes for a multi-user model (Houlsby et al. 2012). The Laplace approximation is a maximum a-posteriori solution that takes the most probable values of parameters rather than integrating over their distributions, and has been shown to perform poorly for classification compared to EP (Nickisch and Rasmussen 2008). However, a drawback of EP is that convergence is not guaranteed (Minka 2001). More importantly, inference for a GP using either method has computational complexity O(N 3 ) and memory complexity O(N 2 ), where N is the number of data points.
The cost of inference can be reduced using a sparse approximation based on a set of inducing points, which act as substitutes for the points in the training dataset. By choosing a fixed number of inducing points, M N, the computational cost is cut to O(N M 2 ), and the memory complexity to O(N M). Inducing points must be selected using either heuristics or by optimising their positions to maximise an estimate of the marginal likelihood. One such sparse approximation is the generalized fully independent training conditional (GFITC) (Naishguzman and Holden 2008; Snelson and Ghahramani 2006), used by Houlsby et al. (2012) for collabGP. However, time and memory costs that grow linearly with O(N) start to become a problem with thousands of data points, as all data must be processed in every iterative update, before any other parameters such as s are updated, making GFITC unsuitable for very large datasets (Hensman et al. 2015).
We derive a more scalable approach for GPPL and crowdGPPL using stochastic variational inference (SVI) (Hoffman et al. 2013). For GPPL, this reduces the time complexity of each iteration to O(P i M 2 + P 2 i M + M 3 ), and memory complexity to O(P i M + M 2 + P 2 i ), where P i is a mini-batch size that we choose in advance. Neither P i nor M are dependent on the size of the dataset, meaning that SVI can be run with arbitrarily large datasets, and other model parameters such as s can be updated before processing all data to encourage faster convergence. First, we define a suitable likelihood approximation to enable the use of SVI.

Approximating the Posterior with a Pairwise Likelihood
The preference likelihood in Equation 2 is not conjugate with the Gaussian process, which means there is no analytic expression for the exact posterior. For single-user GPPL, we therefore approximate the preference likelihood with a Gaussian: where Q is a diagonal noise covariance matrix and we omit the kernel hyperparameters, θ, to simplify notation. For crowdGPPL, we use the same approximation to the likelihood, but replace f with F. We estimate the diagonals of Q by moment matching our approximate likelihood with Φ(z p ), which defines a Bernoulli distribution with variance Q p, p = Φ(z p )(1− Φ(z p )). However, this means that Q depends on z and therefore on f , so the approximate posterior over f cannot be computed in closed form. To resolve this, we approximate Q p, p using an estimated posterior over Φ(z p ) computed independently for each pairwise label, p. We obtain this estimate by updating the parameters of the conjugate prior for the Bernoulli likelihood, which is a beta distribution with parameters γ and λ. We find γ and λ by matching the moments of the beta prior to the prior mean and variance of Φ(z p ), estimated using numerical integration. The prior over Φ(z p ) is defined by a GP for single-user GPPL, p(Φ(z p )|K, α 0 , β 0 ), and a non-standard distribution for crowdGPPL. Given the observed label y p , we estimate the diagonals in Q as the variance of the posterior beta-Bernoulli: The covariance Q therefore approximates the expected noise in the observations, hence captures variance due to σ in Equation 2. This approximation performs well empirically for Gaussian process classification (Reece et al. 2011;Simpson et al. 2017) and classification using extended Kalman filters (Lee and Roberts 2010;Lowne et al. 2010). Unfortunately, the nonlinear term Φ(z) means that the posterior is still intractable, so we replace Φ(z) with a linear function of f by taking the first-order Taylor series expansion of whereẑ is the expectation of z computed using Equation 3, and [i = a] = 1 if i = a and is 0 otherwise. There is a circular dependency betweenf , which is needed to computeẑ, and G. We estimate these terms using a variational inference procedure that iterates between updating f and G (Steinberg and Bonilla 2014) as part of Algorithm 1. The complete approximate posterior for GPPL is now as follows: where Z is a normalisation constant. Linearisation means that our approximate likelihood is conjugate to the prior, so the approximate posterior is also Gaussian. Gaussian approximations to the posterior have shown strong empirical results for classification (Nickisch and Rasmussen 2008) and preference learning (Houlsby et al. 2012), and linearisation using a Taylor expansion has been widely tested in the extended Kalman filter (Haykin 2001) as well as Gaussian processes (Steinberg and Bonilla 2014;Bonilla et al. 2016).

SVI for Single User GPPL
Using the linear approximation in the previous section, posterior inference requires inverting K with computational cost O(N 3 ) and taking an expectation with respect to s, which remains intractable. We address these problems using stochastic variational inference (SVI) with a sparse approximation to the GP that limits the size of the covariance matrices we need to invert. We introduce M N inducing items with inputs X m , utilities f m , and covariance K mm . The covariance between the observed and inducing items is K nm . For clarity, we omit θ from this point on. We assume a mean-field approximation to the joint posterior over inducing and training items that factorises between different sets of latent variables: where q(.) are variational factors defined below. Each factor corresponds to a subset of latent variables, ζ i , and takes the form ln q(ζ i ) = E j i [ln p(ζ i , x, y)]. That is, the expectation with respect to all other latent variables, ζ j , ∀ j i, of the log joint distribution of the observations and latent variables, ζ i . To obtain the factor for f m , we marginalise f and take expectations with respect to q(s): where the variational parametersf m and S are computed using an iterative SVI procedure described below. We choose an approximation of q( f ) that depends only on the inducing point utilities, f m , and is independent of the observations: ln where A = K nm K −1 mm . Therefore, we no longer need to invert an N × N covariance matrix to compute q( f ). The factor q(s) also depends only the inducing points: where α = α 0 + M 2 and β = β 0 + 1 2 tr K −1 mm S +f mf T m . The expected value is E[s] = α β . We apply variational inference to iteratively reduce the KL-divergence between our approximate posterior and the true posterior (Equation 12) by maximising a lower bound, L, on the log marginal likelihood (detailed equations in Appendix A), which is given by: To optimise L, we initialise the q factors randomly, then update each one in turn, taking expectations with respect to the other factors.
The only term in L that refers to the observations, y, is a sum of P terms, each of which refers to one observation only. This means that L can be maximised by considering a random subset of observations at each iteration (Hensman et al. 2013). For the ith update of q ( f m ), we randomly select P i observations y i = {y p ∀p ∈ P i }, where P i is a random subset of indexes of observations, and P i is a mini-batch size. The items referred to by the pairs in the subset are N i = {a p ∀p ∈ P i } ∪ {b p ∀p ∈ P i }. We perform updates using Q i (rows and columns of Q for pairs in P i ), K im and A i (rows of K nm and A in N i ), G i (rows of G in P i and columns in N i ), andẑ i = ẑ p ∀p ∈ P i . The updates optimise the natural parameters of the Gaussian distribution by following the natural gradient (Hensman et al. 2015): where ρ i = (i + ) −r is a mixing coefficient that controls the update rate, π i = P P i weights each update according to sample size, is a delay hyperparameter and r is a forgetting rate (Hoffman et al. 2013).
By performing updates in terms of mini-batches, the time complexity of Equations 17 and 18 is O(P i M 2 + P 2 i M + M 3 ) and memory complexity is O(M 2 + P 2 i + M P i ). The only parameters that must be stored between iterations relate to the inducing points, hence the memory consumption does not grow with the dataset size as in the GFITC approximation used by Houlsby et al. (2012). A further advantage of stochastic updating is that the s parameter (and any other global parameters not immediately depending on the data) can be learned before the entire dataset has been processed, which means that poor initial estimates of s are rapidly improved and the algorithm can converge faster. The complete SVI algorithm is summarised in Algorithm 1. It uses a nested loop to learn G i , which avoids storing the complete matrix, G. It is possible to distribute computation in lines 3-6 by selecting multiple random samples to process in parallel. A global estimate off m and S is passed to each compute node, which runs the loop over lines 4 to 6. The resulting updatedf m and S values are then passed back to a central node that combines them by taking a mean weighted by π i to account for the size of each batch.
Inducing point locations can be learned as part of the variational inference procedure, which breaks convergence guarantees, or by an expensive optimisation process (Hensman et al. 2015). We obtain good performance by choosing inducing points up-front using K-means++ (Arthur and Vassilvitskii 2007) with M clusters to cluster the feature vectors, then taking the cluster centres as inducing points that represent the distribution of observations. The inferred distribution over the inducing points can be used to estimate the posteriors of test items, f (x * ), according to: where C * is the posterior covariance of the test items, K * * is their prior covariance, and K * m is the covariance between test and inducing items.

SVI for CrowdGPPL
We now provide the variational posterior for the crowdGPPL model defined in Equation 6: where U m are the feature vectors of inducing users and the variational q factors are defined below. We use SVI to optimise the lower bound on the log marginal likelihood (detailed in Appendix B), which is given by: The SVI algorithm follows the same pattern as Algorithm 1, updating each q factor in turn by computing means and covariances for V m , W m and t m instead of f m (see Algorithm 2). The time and memory complexity of each update are O(CM 3 items + CM 2 items P i + CM items P 2 i +CM 3 users + CM 2 users P i + CM users P 2 i ) and O(CM 2 items + P 2 i + M items P i + CM 2 users + M users P i ), respectively. The variational factor for the cth inducing item component is: where posterior meanv m,c and covariance S (v) c are computed using equations of the same form as Equations 17 and 18, except Q −1 is scaled by expectations over w m,c , andf m,i is replaced byv m,c,i . The factor for the inducing points of t follows a similar pattern to v m,c : where the equations fort and S (t) are the same as Equations 17 and 18, exceptf m,i is replaced byt m,i . Finally, the variational distribution for each inducing user's component is: whereŵ c and Σ c also follow the pattern of Equations 17 and 18, with Q −1 scaled by expectations of w c,m , andf m,i replaced byŵ m,c,i . We provide the complete equations for the variational means and covariances for v m,c , t m and w m,c in Appendix C. The expectations for inverse scales, c and s (t) can be computed using Equation 15 by substituting the corresponding terms for v c , w c or t instead of f .
Predictions for crowdGPPL can be made by computing the posterior mean utilities, F * , and the covariance Λ * u for each user, u, in the test set: wheret * ,v * c andŵ * c are posterior test means, C * t and C * v,c are posterior covariances of the test items, and ω * c,u is the posterior variance of the user components for u. (see Appendix D, Equations 39 to 41). The mean F * and covariances Λ * u can be inserted into Equation 2 to predict pairwise labels. In practice, the full covariance terms are needed only for Equation 2, so need only be computed between items for which we wish to predict pairwise labels. Our experiments test key aspects of crowdGPPL: predicting consensus utilities and personal preferences from pairwise labels and the scalability of our proposed SVI method. In Section 5.1, we use simulated data to test the robustness of crowdGPPL to noise and unknown numbers of latent components. Section 5.2 compares different configurations of the model against alternative methods using the Sushi datasets3 (Kamishima 2003). Section 5.3 evaluates prediction performance and scalability of crowdGPPL in a high-dimensional NLP task with sparse, noisy crowdsourced preferences (UKPConvArgCrowdSample4, Simpson and Gurevych (2018)). Finally, Section 5.4 evaluates whether crowdGPPL ignores redundant components. The datasets are summarised in Table 1.

Experiments
As baselines, we compare crowdGPPL against GPPL, which we train on all users' preference labels to learn a single utility function, and GPPL-per-user, in which a separate GPPL instance is learned for each user with no collaborative learning. We also compare against the GPVU model (Khan et al. 2014) and collabGP (Houlsby et al. 2012). CollabGP contains parameters for each pairwise label and each user, so has a larger memory footprint than our SVI scheme, which stores only the moments at the inducing points.
We test crowdBT ) as part of a method for predicting consensus utilities from crowdsourced pairwise preferences. CrowdBT models each worker's accuracy, assuming that the differences between workers' labels are due to random errors rather than subjective preferences. Since crowdBT does not account for the item features, it cannot predict utilities for items that were not part of the training set. We therefore treat the posterior mean utilities produced by crowdBT as training labels for Gaussian process regression using SVI. We set the observation noise variance of the GP equal to the crowdBT posterior variance of the utilities to propagate uncertainty from crowdBT to the GP. This pipeline method, crowdBT-GP, tests whether it is sufficient to treat annotator differences as noise, in contrast to the crowdGPPL approach of modelling individual preferences.
We evaluate the methods using the following metrics: accuracy (acc), which is the fraction of correct pairwise labels; cross entropy error (CEE) between the posterior probabilities over pairwise labels and the true labels, which captures the quality of the pairwise posterior; and Kendall's τ, which evaluates the ranking obtained by sorting items by predicted utility.

Simulated Noisy Data
First, we evaluate whether crowdGPPL is able to model individual preferences with varying amounts of labelling noise. We set the number of latent components to C = 20 and all Gamma hyperparameters for crowdGPPL, GPPL and GPPL-per-user to α 0 = 1, β 0 = 100. We use Matérn 3/2 kernels with the length-scale for each dimension of the feature vector, d, chosen by a median heuristic: This is a computationally frugal way to choose the length-scales, that has been extensively used in various kernel methods (e.g., Bors and Pitas (1996); Gretton et al. (2012)). The SVI hyperparameters were set to ρ = 0.9, P i = 1000 and = 1. Hoffman et al. (2013) found that higher values of ρ gave better final results but slightly slower convergence, recommending 0.9 as a good balance across several datasets, and did not find any effect from changing . We follow their recommendations and do not find it necessary to perform further tuning in our experiments. Both M and P i are constrained in practice by the computational resources available -we investigate these further in Section 5.3. In simulation (a), to test consensus prediction, we generate a 20 × 20 grid of points and split them into 50% training and test sets. For each gridpoint, we generate pairwise labels by drawing from the generative model of crowdGPPL with U = 20 users, C = 5, each s (v) c set to random values between 0.1 and 10, and s (w) c = 1, ∀c. We vary s (t) to control the noise in the consensus function. We train and test crowdGPPL with C = U and repeat the complete experiment 25 times, including generating new data. Figure 1a shows that crowdGPPL better recovers the consensus ranking than the baselines, even as noise increases, as GPPL's predictions are worsened by biased users who deviate consistently from the consensus. For GPPL-per-user, the consensus is simply the mean of all users' predicted utilities, so does not benefit from sharing information between users when training. For simulation (b), we modify the previous setup by fixing s (t) = 5 and varying s (v) c , ∀c to evaluate the methods' ability to recover the personal preferences of simulated users. The results in Figure 1b show that crowdGPPL is able to make better predictions when noise is below 0.3.
We hypothesise that crowdGPPL can recover latent components given sufficient training data. In simulation (c), we generate data using the same setup as before, but fix s (t) = s (v) c = s (w) = 1, ∀c and vary the number of pairwise training labels and the number of true components through C true ∈ {1, 3, 10, 20}. We match inferred components to the true components as follows: compute Pearson correlations between each unmatched true component and each unmatched inferred component; select the pair with the highest correlation as a match; repeat until all true components are matched. In Figure 1c we plot the mean correlation between matched pairs of components. For all values of C true , increasing the number of training labels beyond 700 brings little improvement. Performance is highest when C true = 20, possibly because the predictive model has C = 20, so is a closer match to the generating model. However, crowdGPPL is able to recover latent components reasonably well for all values of C true given > 500 labels, despite mismatches between C and C true .

Sushi Preferences
The sushi datasets contain, for each user, a gold standard preference ranking of 10 types of sushi, from which we generate gold-standard pairwise labels. To test performance with very few training pairs, we obtain Sushi-A-small by selecting 100 users at random from the complete Sushi-A dataset, then selecting 5 pairs for training and 25 for testing per user. For Sushi-A, we select 100 users at random from the complete dataset, then split the data into training and test sets by randomly selecting 20 training and 25 test pairs per user. For Sushi-B, we use all 5000 workers, and subsample 10 training and 1 test pair per user.
We compare standard crowdGPPL with four other variants: -crowdGPPL\inducing: does not use the sparse inducing point approximation and instead uses all the original points in the training set; -crowdGPPL\u: ignores the user features; -crowdGPPL\u\x: ignores both user and item features; -crowdGPPL\u\t: excludes the consensus function t from the model as well as the user features. For methods with \u, the user covariance matrix, L, is replaced by the identity matrix, and for crowdGPPL\u\x, K is also replaced by the identity matrix. As the user features do not contain detailed, personal information (only region, age group, gender, etc.), they are not expected to be sufficiently informative to predict personal preferences on their own. Therefore, for crowdGPPL and crowdGPPL\inducing, we compute L for 10 latent components using the Matérn 3/2 kernel function and use the identity matrix for the remaining 10. CollabGP is also tested with and without user features. We set hyperparameters C = 20, = 1, ρ = 0.9, P i = 200 for Sushi-A-small and Sushi-A, and P i = 2000 for Sushi-B, without optimisation. For the gamma hyperparameters, a grid search over {10 −1 , ..., 10 3 } on withheld user data from Sushi-A resulted in α 0 = 1, β 0 = 100 for GPPL variants, and α (t) = 10 for crowdGPPL variants. The complete process of subsampling, training and testing, was repeated 25 times for each dataset.
The results in Table 2 illustrate the benefit of personalised models over single-user GPPL. The inducing point approximation does not appear to harm performance of crowdGPPL, but including the user features tends to decrease its performance compared to crowdGPPL\u and crowdGPPL\u\x, except on Sushi-A-small, where they may help with the small amount of training data. Comparing crowdGPPL\u with crowdGPPL\u\t, including the consensus function improves performance modestly. The strong performance of GPPL-per-user suggests that even 10 pairs per person were enough to learn a reasonable model for Sushi-B. As expected, the more memory-intensive collabGP performs comparably well to crowdGPPL on accuracy and CEE but does not provide a ranking function for computing Kendall's τ. GPVU does not perform as well as other personalised methods on Sushi-A and Sushi-B, potentially due to its maximum likelihood inference steps. The results show that crowdGPPL is competitive despite the approximate SVI method, so in the next experiment, we test the approach on a larger crowdsourced dataset where low memory consumption is required.

Argument Convincingness
We evaluate consensus learning, personal preference learning and scalability on an NLP task, namely, ranking arguments by convincingness. The task requires learning from crowdsourced data, but is not simply an aggregation task as it requires learning a predictor for test documents that were not compared by the crowd. The dataset, UKPConvArgCrowdSample, was subsampled by Simpson and Gurevych (2018) from raw data provided by Habernal and Gurevych (2016), and contains arguments written by users of online debating forums, with crowdsourced judgements of pairs of arguments indicating the most convincing argument. The data is divided into 32 folds (16 topics, each with 2 opposing stances). For each fold, we train on 31 folds and test on the remaining fold. We extend the task to predicting both the consensus and personal preferences of individual crowd workers. GPPL previously outperformed SVM and Bi-LSTM methods at consensus prediction for UKPConvArgCrowdSample (Simpson and Gurevych 2018). We hypothesise that a worker's view of convincingness depends on their personal view of the subject discussed, so crowdGPPL may outperform GPPL and crowdBT-GP on both consensus and personal preference prediction.
The dataset contains 32, 310 linguistic and embedding features for each document (we use mean GloVe embeddings for the words in each document, see Simpson and Gurevych Table 3 UKPConvArgCrowdSample: predicting consensus, personal preferences for all workers, and personal preferences for workers with >50 pairs in the training set. (2018)). The high-dimensionality of the input feature vectors requires us to modify the length-scale heuristic for all GP methods, as the distance between items grows with the number of dimensions, which causes the covariance to shrink to very small values. We therefore use l d,scaledMH = 20 = 10. We do not optimise α 0 , but choose β 0 by comparing training set accuracy for GPPL with β 0 ∈ {2, 200, 20000}. The best value of β 0 is also used for β (t) 0 and β (v) 0 , then training set accuracy of crowdGPPL is used to select β (w) 0 ∈ {1, 10, 100}. We set C = 50, M = 500, P i = 200, = 10, and ρ = 0.9 without optimisation. Table 3 shows that crowdGPPL outperforms both GPPL and crowdBT-GP at predicting both the consensus and personal preferences (significant for Kendall's τ with p < 0.05, Wilcoxon signed-rank test), suggesting that there is a benefit to modelling individual workers in subjective, crowdsourced tasks. We also compare against crowdGPPL without the consensus (crowdGPPL\t) and find that including t in the model improves personalised predictions. This is likely because many workers have few training pairs, so the consensus helps to identify arguments that are commonly considered very poor or very convincing. Table 3 also shows that for workers with more than 50 pairs in the training set, accuracy and CEE improve for all methods but τ decreases, suggesting that some items may be ranked further away from their correct ranking for these workers. It is possible that workers who were willing to complete more annotations (on average 31 per fold) deviate further from the consensus, and crowdGPPL does not fully capture their preferences given the data available.
We examine the scalability of our SVI method by evaluating GPPL and crowd-GPPL with different numbers of inducing points, M, and different mini-batch sizes, P i . Figure 2a shows the trade-off between runtime and training set accuracy as an effect of choosing M. Accuracy levels off as M increases, while runtime continues to increase rapidly in a polynomial fashion. Using inducing points can therefore give a large improvement in runtimes with a fairly small performance hit. Figure 2b demonstrates that smaller batch sizes do not negatively affect the accuracy, although they increase runtimes as more iterations are required for convergence. The runtimes flatten out as P i increases, so we recommend choosing P i ≥ 200 but small enough to complete an iteration rapidly with the computational resources available. Figures  2c and 2d show runtimes as a function of the number of items in the training set, N, and the number of pairwise training labels, P, respectively (all other settings remain as in Figure  2a). In both cases, the increases to runtime are small, despite the growing dataset size.

Posterior Variance of Item Components
We investigate how many latent components were actively used by crowdGPPL on the UKPConvArgCrowdSample and Sushi-A datasets. Figure 3 plots the posterior expectations of the inferred scales, 1/ s (v) c s (w) c , for the latent item components. The plots show that many factors have a relatively small variance and therefore do not contribute to many of the model's predictions. This indicates that our Bayesian approach will only make use of components that are supported by the data, even if C is larger than required.

Conclusions
We proposed a novel Bayesian preference learning approach for modelling both the preferences of individuals and the overall consensus of a crowd. Our model learns the latent utilities of items from pairwise comparisons using a combination of Gaussian processes and Bayesian matrix factorisation to capture differences in opinion. We introduce a stochastic variational inference (SVI) method, that, unlike previous work, can scale to arbitrarily large datasets, since its time and memory complexity do not grow with the dataset size. Our experiments confirm the method's scalability and show that jointly modelling the consensus and personal preferences can improve predictions of both. Our approach performs competitively against less scalable alternatives and improves on the previous state of the art for predicting argument convincingness from crowdsourced data (Simpson and Gurevych 2018).
Future work will investigate learning inducing point locations and optimising length-scale hyperparameters by maximising the variational lower bound, L, as part of the variational inference method. Another important direction will be to generalise the likelihood from pairwise comparisons to comparisons involving more than two items  or best-worst scaling (Kiritchenko and Mohammad 2017)

A Variational Lower Bound for GPPL
Due to the non-Gaussian likelihood, Equation 2, the posterior distribution over f contains intractable integrals: We can derive a variational lower bound as follows, beginning with an approximation that does not use inducing points: Writing out the expectations in terms of the variational parameters, we get: The expectation over the likelihood can be computed using numerical integration. Now we can introduce the sparse approximation to obtain the bound in Equation 16: where the terms relating to E p(f | f m ) − q(f ) cancel.

B Variational Lower Bound for crowdGPPL
For crowdGPPL, our approximate variational lower bound is:

C Posterior Parameters for Variational Factors in CrowdGPPL
For the latent item components, the posterior precision estimate for S −1 v, c at iteration i is given by: where A i = K i m K −1 mm ,ŵ c and Σ c are the variational mean and covariance of the cth latent user component (defined below in Equations 37 and 36), and u = {u p ∀p ∈ P i } is the vector of user indexes in the sample of observations. We use S −1 v, c to compute the means for each row of V m : For the consensus, the precision and mean are updated according to the following: For the latent user components, the SVI updates for the parameters are: where A * m = K * m K −1 mm , A (w) u m = L u m L −1 mm and L u m is the covariance between user u and the inducing users.

E Mathematical Notation
A list of symbols is provided in Tables 4 and 5 indicates that the variable refers to the test set, rather than the training set Pairwise preference labels y(a, b) a binary label indicating whether item a is preferred to item b y p the pth pairwise label in a set of observations y the set of observed values of pairwise labels Φ cumulative density function of the standard Gaussian (normal) distribution x a the features of item a (a numerical vector) X the features of all items in the training set D the size of the feature vector N number of items in the training set P number of pairwise labels in the training set x * the features of all items in the test set δ a observation noise in the utility of item a σ 2 variance of the observation noise in the utilities z p the difference in utilities of items in pair p, normalised by its total variance z set of z p values for training pairs Table 4 Table of symbols used to represent variables in this paper (continued on next page in Table 5).

Symbol Meaning
GPPL (some terms also appear in crowdGPPL) f latent utility function over items in single-user GPPL f utilities, i.e., values of the latent utility function for a given set of items prior covariance of the inducing items K nm prior covariance between training and inducing items S posterior covariance of the inducing items; in crowdGPPL, a superscript and subscript indicate which variable this is the posterior covariance for Σ posterior covariance over the latent user components A K nm K −1 mm G linearisation term used to approximate the likelihood a posterior shape parameter for the Gamma distribution over s b posterior scale parameter for the Gamma distribution over s ρ i a mixing coefficient, i.e., a weight given to the ith update when combining with current values of variational parameters delay r forgetting rate π i weight given to the update at the ith iteration P i subset of pairwise labels used in the ith iteration P i number of pairwise labels in the ith iteration subsample U i number of users referred to in the ith subsample u users in the ith subsample a indexes of first items in the pairs in the ith subsample b indexes of first items in the pairs in the ith subsample