Caron 2012 - Plackett-Luce Model for Full Rankings

Summary

The Plackett-Luce (PL) model generalises Bradley-Terry to ranked lists: pick the winner among all items with probability proportional to skill, remove it, repeat. A latent exponential variable per ranking position gives a Gamma Gibbs sampler and Hunter’s MM update as EM.

Overview

Racing results, preference orderings from surveys, and ranked search results are lists over of the items. PL is the “exploded logit” of choice modelling: a sequence of multinomial-logit choices from shrinking choice sets (Discrete Choice Models).

Main Content

Plackett-Luce likelihood

The last position contributes a factor 1, so only stages appear.

Latent variables

For each ranking and stage : (waiting time until the first of the remaining items arrives). Complete log-likelihood: .

EM and Gibbs for Plackett-Luce

Let = number of rankings in which item is not in the last position, and .

  • EM (MAP, prior ): . For this is the Hunter (2004, p. 398) MM update.
  • Gibbs: , then .

Proof sketch. The numerator count is the number of stages at which is the “winner”; the rate accumulates exposure . This is the Poisson-process/exponential-family analogue of a Gamma-Poisson conjugate pair.

Extensions (stated in the paper): mixtures of PL models (Gormley & Murphy 2008) reuse the same augmentation for the within-component update.

Examples

Ranking four creatives

Setup. Five panelists rank creatives A-D: ABCD, ABCD, BACD, ABCD, ACBD. Flat prior. Solution. Wins in the sense of : A is not last in 5 rankings, B in 5, C in 5, D in 0 (D is last in all five). So and the MLE for is zero; the MLE does not exist as a finite positive value. Under the Gamma prior (), gets the posterior , positive and shrunk. Interpretation. This is exactly the NASCAR issue (drivers always last) discussed in Caron 2012 - Experiments NASCAR and Chess; Hunter’s MLE required deleting such drivers, the Bayesian model does not.

import numpy as np
def pl_em(rankings, K, a=1.0, b=0.0, iters=300):
    lam = np.full(K, 1.0/K)
    w = np.zeros(K)
    for r in rankings:
        for k in r[:-1]: w[k] += 1
    for _ in range(iters):
        denom = np.full(K, b)
        for r in rankings:
            tail = np.array([lam[r[j:]].sum() for j in range(len(r)-1)])
            for j in range(len(r)-1):
                for k in r[j:]: denom[k] += 1.0/tail[j]
        lam = (a-1+w)/denom
        lam /= lam.sum()
    return lam
print(pl_em([[0,1,2,3],[0,1,2,3],[1,0,2,3],[0,1,2,3],[0,2,1,3]], 4, a=2, b=3))

PyMC-style sketch (untested): PL log-likelihood can be written with pm.math.logsumexp over suffix sets, or via pm.Potential; E67 applies it to Formula 1 finishing orders.

Connections

See Also

Caron 2012 - Home Advantage, Ties and Team Comparisons · Caron 2012 - Identifiability, Hyperparameters and Further Extensions