 # Exponential Family Graph Matching and Ranking

We present a method for learning max-weight matching predictors in bipartite graphs. The method consists of performing maximum a posteriori estimation in exponential families with sufficient statistics that encode permutations and data features. Although inference is in general hard, we show that for one very relevant application - web page ranking - exact inference is efficient. For general model instances, an appropriate sampler is readily available. Contrary to existing max-margin matching models, our approach is statistically consistent and, in addition, experiments with increasing sample sizes indicate superior improvement over such models. We apply the method to graph matching in computer vision as well as to a standard benchmark dataset for learning web page ranking, in which we obtain state-of-the-art results, in particular improving on max-margin variants. The drawback of this method with respect to max-margin alternatives is its runtime for large graphs, which is comparatively high.

Comments

There are no comments yet.

## Authors

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

The Maximum-Weight Bipartite Matching Problem (henceforth ‘matching problem’) is a fundamental problem in combinatorial optimization

. This is the problem of finding the ‘heaviest’ perfect match in a weighted bipartite graph. An exact optimal solution can be found in cubic time by standard methods such as the Hungarian algorithm.

This problem is of practical interest because it can nicely model real-world applications. For example, in computer vision the crucial problem of finding a correspondence between sets of image features is often modeled as a matching problem [2, 3]. Ranking algorithms can be based on a matching framework , as can clustering algorithms [14, 11].

When modeling a problem as one of matching, one central question is the choice of the weight matrix. The problem is that in real applications we typically observe edge feature vectors

, not edge weights. Consider a concrete example in computer vision: it is difficult to tell what the ‘similarity score’ is between two image feature points, but it is straightforward to extract feature vectors (e.g. SIFT) associated with those points.

In this setting, it is natural to ask whether we could parameterize the features, and use labeled matches in order to estimate the parameters such that, given graphs with ‘similar’ features, their resulting max-weight matches are also ‘similar’. This idea of ‘parameterizing algorithms’ and then optimizing for agreement with data is called structured estimation [31, 33].

 and  describe max-margin structured estimation formalisms for this problem. Max-margin structured estimators are appealing in that they try to minimize the loss that one really cares about (‘structured losses’, of which the Hamming loss is an example). However structured losses are typically piecewise constant in the parameters, which eliminates any hope of using smooth optimization directly. Max-margin estimators instead minimize a surrogate loss which is easier to optimize, namely a convex upper bound on the structured loss . In practice the results are often good, but known convex relaxations produce estimators which are statistically inconsistent 

, i.e., the algorithm in general fails to obtain the best attainable model in the limit of infinite training data. The inconsistency of multiclass support vector machines is a well-known issue in the literature that has received careful examination recently

[8, 7].

Motivated by the inconsistency issues of max-margin structured estimators as well as by the well-known benefits of having a full probabilistic model, in this paper we present a maximum a posteriori (MAP) estimator for the matching problem. The observed data are the edge feature vectors and the labeled matches provided for training. We then maximize the conditional posterior likelihood of matches given the observed data. We build an exponential family model where the sufficient statistics are such that the mode of the distribution (the prediction) is the solution of a max-weight matching problem. The resulting partition function is P-complete to compute exactly. However, we show that for learning to rank applications the model instance is tractable. We then compare the performance of our model instance against a large number of state-of-the-art ranking methods, including DORM , an approach that only differs to our model instance by using max-margin instead of a MAP formulation. We show very competitive results on standard webpage ranking datasets, and in particular we show that our model performs better than or on par with DORM. For intractable model instances, we show that the problem can be approximately solved using sampling and we provide experiments from the computer vision domain. However the fastest suitable sampler is still quite slow for large models, in which case max-margin matching estimators like those of  and  are likely to be preferable even in spite of their potential inferior accuracy.

## 2 Background

### 2.1 Structured Prediction

In recent years, great attention has been devoted in Machine Learning to so-called structured predictors, which are predictors of the kind

 gθ:\Xcal↦\Ycal, (1)

where is an arbitrary input space and is an arbitrary discrete space, typically exponentially large. may be, for example, a space of matrices, trees, graphs, sequences, strings, matches, etc. This structured nature of is what structured prediction refers to. In the setting of this paper, is the set of vector-weighted bipartite graphs (i.e., each edge has a feature vector associated to it), and is the set of perfect matches induced by . If graphs are available, along with corresponding annotated matches (i.e., a set ), our task will be to estimate such that when we apply the predictor to a new graph it produces a match that is similar to matches of similar graphs from the annotated set. Structured learning or structured estimation refers to the process of estimating a vector for predictor when data are available. Structured prediction for input means computing using the estimated .

Two generic estimation strategies have been popular in producing structured predictors. One is based on max-margin estimators [33, 32, 31], and the other on maximum-likelihood (ML) or MAP estimators in exponential family models .

The first approach is a generalization of support vector machines to the case where the set is structured. However the resulting estimators are known to be inconsistent in general: in the limit of infinite training data the algorithm fails to recover the best model in the model class [22, 7, 8]. McAllester recently provided an interesting analysis on this issue, where he proposed new upper bounds whose minimization results in consistent estimators, but no such bounds are convex . The other approach uses ML or MAP estimation in conditional exponential families with ‘structured’ sufficient statistics, such as in probabilistic graphical models, where they are decomposed over the cliques of the graph (in which case they are called Conditional Random Fields, or CRFs ). In the case of tractable graphical models, dynamic programming can be used to efficiently perform inference. Other tractable models of this type include models that predict spanning trees and models that predict binary labelings in planar graphs [9, 17]. ML and MAP estimators in exponential families not only amount to solving an unconstrained and convex optimization problem; in addition they are statistically consistent. The main problem with these types of models is that often the partition function is intractable. This has motivated the use of max-margin methods in many scenarios where such intractability arises.

### 2.2 The Matching Problem

Consider a weighted bipartite graph with nodes in each part, , where is the set of vertices, is the set of edges and is a set of real-valued weights associated to the edges. can be simply represented by a matrix () where the entry is the weight of the edge . Consider also a bijection , i.e., a permutation. Then the matching problem consists of computing

 y∗=\argmaxym∑i=1wiy(i). (2)

This is a well-studied problem; it is tractable and can be solved in time [16, 26]. This model can be used to match features in images , improve classification algorithms  and rank webpages , to cite a few applications. The typical setting consists of engineering the score matrix according to domain knowledge and subsequently solving the combinatorial problem.

## 3 The Model

### 3.1 Basic Goal

In this paper we assume that the weights are instead to be estimated from training data. More precisely, the weight associated to the edge in a graph will be the result of an appropriate composition of a feature vector (observed) and a parameter vector (estimated from training data). Therefore, in practice, our input is a vector-weighted bipartite graph (), which is ‘evaluated’ at a particular (obtained from previous training) so as to attain the graph . See Figure 1 for an illustration. Figure 1: Left: Illustration of an input vector-weighted bipartite graph Gx with 3×3 edges. There is a vector xe associated to each edge e (for clarity only xij is shown, corresponding to the solid edge). Right: weighted bipartite graph G obtained by evaluating Gx on the learned vector θ (again only edge ij is shown).

More formally, assume that a training set is available, where . Here is the number of nodes in each part of the vector-weighted bipartite graph . We then parameterize as , and the goal is to find the which maximizes the posterior likelihood of the observed data. We will assume to be bilinear, i.e., .

### 3.2 Exponential Family Model

We assume an exponential family model, where the probability model is

 p(y|x;θ)=exp(\innerϕ(x,y)θ−g(x;θ)), where (3)
 g(x;θ)=log∑yexp\innerϕ(x,y)θ (4)

is the log-partition function, which is a convex and differentiable function of .

The prediction in this model is the most likely , i.e.,

 y∗=\argmaxyp(y|x;θ)=\argmaxy\innerϕ(x,y)θ (5)

and ML estimation amounts to maximizing the conditional likelihood of the training set , i.e., computing . In practice we will in general introduce a prior on and perform MAP estimation:

 θ∗=\argmaxθp(Y|X;θ)p(θ)=\argmaxθp(θ|Y,X). (6)

Assuming iid sampling, we have . Therefore,

 p(θ|Y,X)∝p(θ)N∏n=1exp(\innerϕ(xn,yn)θ−g(xn;θ)) = exp(logp(θ)+N∑n=1(\innerϕ(xn,yn)θ−g(xn;θ))). (7)

We impose a Gaussian prior on . Instead of maximizing the posterior we can instead minimize the negative log-posterior

, which becomes our loss function (we suppress the constant term):

 ℓ(Y|X;θ)= λ2\nbrθ2+1NN∑n=1(g(xn;θ)−\innerϕ(xn,yn)θ) (8)

where is a regularization constant. is a convex function of since the log-partition function is a convex function of  and the other terms are clearly convex in .

### 3.3 Feature Parameterization

The critical observation now is that we equate the solution of the matching problem eq:lap to the prediction of the exponential family model eq:argmax, i.e., . Since our goal is to parameterize features of individual pairs of nodes (so as to produce the weight of an edge), the most natural model is

 ϕ(x,y) =M∑i=1xiy(i), which gives (9) wiy(i) =\innerxiy(i)θ, (10)

i.e., linear in both and (see Figure 1, right). The specific form for will be discussed in the experimental section. In light of eq:param, eq:lap now clearly means a prediction of the best match for under the model .

## 4 Learning the Model

### 4.1 Basics

We need to solve . is a convex and differentiable function of , therefore gradient descent will find the global optimum. In order to compute , we need to compute . It is a standard result of exponential families that the gradient of the log-partition function is the expectation of the sufficient statistics:

 ∇θg(x;θ)=\Eby∼p(y|x;θ)[ϕ(x,y)]. (11)

Therefore in order to perform gradient descent we need to compute the above expectation. Opening the above expression gives

 \Eby∼p(y|x;θ)[ϕ(x,y)]=∑yϕ(x,y)p(y|x;θ) (12) =1Z(x;θ)∑yϕ(x,y)M∏i=1exp(\innerxiy(i)θ), (13)

which reveals that the partition function needs to be computed. The partition function is:

 Z(x;θ)=∑yM∏i=1exp(\innerxiy(i)θ)=:Biy(i). (14)

Note that the above is the expression for the permanent of matrix . The permanent is similar in definition to the determinant, the difference being that for the latter comes before the product. However, unlike the determinant, which is computable efficiently and exactly by standard linear algebra manipulations , computing the permanent is a P-complete problem . Therefore we have no realistic hope of computing eq:grad exactly for general problems.

### 4.2 Exact Expectation

The exact partition function itself can be efficiently computed for up to about using the algorithm by Ryser . However for arbitrary expectations we are not aware of any exact algorithm which is more efficient than full enumeration (which would constrain tractability to very small graphs). However we will see that even in the case of very small graphs we find a very important application: learning to rank. In our experiments, we successfully apply a tractable instance of our model to benchmark webpage ranking datasets, obtaining very competitive results. For larger graphs, we have alternative options as indicated below.

### 4.3 Approximate Expectation

If we have a situation in which the set of feasible permutations is too large to be fully enumerated efficiently, we need to resort to some approximation for the expectation of the sufficient statistics. The best solution we are aware of is one by Huber and Law, who recently presented an algorithm to approximate the permanent of dense non-negative matrices . The algorithm works by producing exact samples from the distribution of perfect matches on weighted bipartite graphs. This is in precisely the same form as the distribution we have here, . We can use this algorithm for applications that involve larger graphs.111The algorithm is described in the appendix. We generate samples from the distribution , and directly approximate eq:expectation1 with a Monte Carlo estimate

 \Eby∼p(y|x;θ)[ϕ(x,y)]≈1KK∑i=1ϕ(x,yi). (15)

In our experiments, we apply this algorithm to an image matching application.

## 5 Experiments

### 5.1 Ranking

Here we apply the general matching model introduced in previous sections to the task of learning to rank. Ranking is a fundamental problem with applications in diverse areas such as document retrieval, recommender systems, product rating and others. We focus on web page ranking.

We are given a set of queries and, for each query , a list of documents with corresponding ratings (assigned by a human editor), measuring the relevance degree of each document with respect to query . A rating or relevance degree is usually a nominal value in the list , where is typically between 2 and 5. We are also given, for every retrieved document , a joint feature vector for that document and the query .

Training At training time, we model each query as a vector-weighted bipartite graph (Figure 1) where the nodes on one side correspond to a subset of cardinality of all documents retrieved by the query, and the nodes on the other side correspond to all possible ranking positions for these documents (). The subset itself is chosen randomly, provided at least one exemplar document of every rating is present. Therefore must be such that .

The process is then repeated in a bootstrap manner: we resample (with replacement) from the set of documents , documents at a time (conditioned on the fact that at least one exemplar of every rating is present, but otherwise randomly). This effectively boosts the number of training examples since each query ends up being selected many times, each time with a different subset of documents from the original set of documents.

In the following we drop the query index to examine a single query. Here we follow the construction used in  to map matching problems to ranking problems (indeed the only difference between our ranking model and that of  is that they use a max-margin estimator and we use MAP in an exponential family.) Our edge feature vector will be the product of the feature vector associated with document , and a scalar (the choice of which will be explained below) associated with ranking position

 xij=ψicj. (16)

is dataset specific (see details below). From eq:param and eq:psi, we have , and training proceeds as explained in Section 4.

Testing At test time, we are given a query and its corresponding list of associated documents. We then have to solve the prediction problem, i.e.,

 y∗= \argmaxyD∑i=1\innerxiy(i)θ=\argmaxyD∑i=1cy(i)\innerψiθ. (17)

We now notice that if the scalar , where is a non-increasing function of rank position , then eq:argmax_ranking1 can be solved simply by sorting the values of in decreasing order.222If denotes the vector of ranks of entries of vector , then is maximized by the permutation such that , a theorem due to Polya, Littlewood, Hardy and Blackwell . In other words, the matching problem becomes one of ranking the values . Inference in our model is therefore very fast (linear time).333Sorting the top items of a list of items takes time . In this setting it makes sense to interpret the quantity as a score of document for query . This leaves open the question of which non-increasing function should be used. We do not solve this problem in this paper, and instead choose a fixed . In theory it is possible to optimize over during learning, but in that case the optimization problem would no longer be convex. We describe the results of our method on LETOR 2.0 , a publicly available benchmark data collection for comparing learning to rank algorithms. It is comprised of three data sets: OHSUMED, TD2003 and TD2004.

Data sets

OHSUMED contains features extracted from query-document pairs in the OHSUMED collection, a subset of MEDLINE, a database of medical publications. It contains 106 queries. For each query there are a number of associated documents, with relevance degrees judged by humans on three levels:

definitely, possibly or not relevant. Each query-document pair is associated with a 25 dimensional feature vector, . The total number of query-document pairs is 16,140. TD2003 and TD2004 contain features extracted from the topic distillation tasks of TREC 2003 and TREC 2004, with 50 and 75 queries, respectively. Again, for each query there are a number of associated documents, with relevance degrees judged by humans, but in this case only two levels are provided: relevant or not relevant. Each query-document pair is associated with a 44 dimensional feature vector, . The total number of query-document pairs is 49,171 for TD2003 and 74,170 for TD2004. All datasets are already partitioned for 5-fold cross-validation. See  for more details.

Evaluation Metrics In order to measure the effectiveness of our method we use the normalized discount cumulative gain (NDCG) measure  at rank position , which is defined as

 \emph{NDCG@k}=1Zk∑j=12r(j)−1log(1+j), (18)

where is the relevance of the document in the list, and is a normalization constant so that a perfect ranking yields an NDCG score of . Figure 2: Results of NDCG@k for state-of-the-art methods on TD2004 (left), TD2003 (middle) and OHSUMED (right). This is best viewed in color.

External Parameters The regularization constant is chosen by 5-fold cross-validation, with the partition provided by the LETOR package. All experiments are repeated 5 times to account for the randomness of the sampling of the training data. We use on all experiments.

Optimization To optimize eq:loss we use a standard BFGS Quasi-Newton method with a backtracking line search, as described in .

Results For the first experiment training was done on subsets sampled as described above, where for each query we sampled subsets, therefore increasing the number of samples linearly with . For TD2003 we also trained with all possible subsets ( in the plots). In Figure 2 we plot the results of our method (named RankMatch), for , compared to those achieved by a number of state-of-the-art methods which have published NDCG scores in at least two of the datasets: RankBoost , RankSVM , FRank , ListNet , AdaRank , QBRank , IsoRank , SortNet , StructRank  and C-CRF . We also included a plot of our implementation of DORM , using precisely the same resampling methodology and data for a fair comparison. RankMatch performs among the best methods on both TD2004 and OHSUMED, while on TD2003 it performs poorly (for low ) or fairly well (for high ).

We notice that there are four methods which only report results in two of the three datasets: the two SortNet versions are only reported on TD2003 and TD2004, while StructRank and C-CRF are only reported on TD2004 and OHSUMED. RankMatch compares similarly with SortNet and StructRank on TD2004, similarly to C-CRF and StructRank on OHSUMED and similarly to the two versions of SortNet on TD2003. This exhausts all the comparisons against the methods which have results reported in only two datasets. A fairer comparison could be made if these methods had their performance published for the respective missing dataset.

When compared to the methods which report results in all datasets, RankMatch entirely dominates their performance on TD2004 and is second only to IsoRank on OHSUMED (and performing similarly to QBRank).

These results should be interpreted cautiously;  presents an interesting discussion about issues with these datasets. Also, benchmarking of ranking algorithms is still in its infancy and we don’t yet have publicly available code for all of the competitive methods. We expect this situation to change in the near future so that we are able to compare them on a fair and transparent basis.

Consistency In a second experiment we trained RankMatch with different training subset sizes, starting with and going up to . Once again, we repeated the experiments with DORM using precisely the same training subsets. The purpose here is to see whether we observe a practical advantage of our method with increasing sample size, since statistical consistency only provides an asymptotic indication. The results are plotted in Figure 3-right, where we can see that, as more training data is available, RankMatch improves more saliently than DORM.

Runtime The runtime of our algorithm is competitive with that of max-margin for small graphs, such as those that arise from the ranking application. For larger graphs, the use of the sampling algorithm will result in much slower runtimes than those typically obtained in the max-margin framework. This is certainly the benefit of the max-margin matching formulations of [3, 19]: it is much faster for large graphs. Table 1 shows the runtimes for graphs of different sizes, both for exponential family and max-margin matching models.

### 5.2 Image Matching

For our computer vision application we used a silhouette image from the Mythological Creatures 2D database. We randomly selected 20 points on the silhouette as our interest points and applied shear to the image creating 200 different images. We then randomly selected pairs of images for training, for validation and 500 for testing, and trained our model to match the interest points in the pairs. In this setup,

 xij=|ψi−ψj|2, (19)

where denotes the elementwise difference and is the Shape Context feature vector  for point .

For a graph of this size computing the exact expectation is not feasible, so we used the sampling method described in Section 4.3. Once again, the regularization constant was chosen by cross-validation. Given the fact that the MAP estimator is consistent while the max-margin estimator is not, one is tempted to investigate the practical performance of both estimators as the sample size grows. However, since consistency is only an asymptotic property, and also since the Hamming loss is not the criterion optimized by either estimator, this does not imply a better large-sample performance of MAP in real experiments. In any case, we present results with varying training set sizes in Figure 3-left. The max-margin method is that of . After a sufficiently large training set size, our model seems to enjoy a slight advantage. Figure 3: Performance with increasing sample size. Left: hamming loss for different numbers of training pairs in the image matching problem (test set size fixed to 500 pairs). Right: results of NDCG@1 on the ranking dataset OHSUMED. This evidence is in agreement with the fact that our estimator is consistent, while max-margin is not.

## 6 Conclusion and Discussion

We presented a method for learning max-weight bipartite matching predictors, and applied it extensively to well-known webpage ranking datasets, obtaining state-of-the-art results. We also illustrated–with an image matching application–that larger problems can also be solved, albeit slowly, with a recently developed sampler. The method has a number of convenient features. First, it consists of performing maximum-a-posteriori estimation in an exponential family model, which results in a simple unconstrained convex optimization problem solvable by standard algorithms such as BFGS. Second, the estimator is not only statistically consistent but also in practice it seems to benefit more from increasing sample sizes than its max-margin alternative. Finally, being fully probabilistic, the model can be easily integrated as a module in a Bayesian framework, for example. The main direction for future research consists of finding more efficient ways to solve large problems. This will most likely arise from appropriate exploitation of data sparsity in the permutation group.

## References

•  Belongie, S., & Malik, J (2000). Matching with shape contexts. CBAIVL00.
•  Belongie, S., Malik, J., & Puzicha, J. (2002). Shape matching and object recognition using shape contexts. IEEE Trans. on PAMI, 24, 509–521.
•  Caetano, T. S., Cheng, L., Le, Q. V., & Smola, A. J. (2009). Learning graph matching. IEEE Trans. on PAMI, 31, 1048–1058.
•  Cao, Z., Qin, T., Liu, T.-Y., Tsai, M.-F., & Li, H. (2007). Learning to rank: from pairwise approach to listwise approach. ICML
•  Tsai, M., Liu, T., Qin, T., Chen, H., & Ma, W. (2007). Frank: A ranking method with fidelity loss. SIGIR.
•  Freund, Y., Iyer, R., Schapire, R. E., & Singer, Y. (2003). An efficient boosting algorithm for combining preferences. J. Mach. Learn. Res., 4, 933–969.
•  Liu, Y. & Shen, X. (2006) Multicategory -learning. JASA, 101, 500–509.
•  Liu, Y. & Shen, X. (2005) Multicategory -learning and support vector machine: Computational tools. J. Computational and Graphical Statistics, 14, 219–236.
•  Globerson, A., & Jaakkola, T. (2007). Approximate inference using planar graph decomposition. NIPS.
•  Herbrich, A., Graepel, T., & Obermayer, K. (2000). Large margin rank boundaries for ordinal regression. In

Advances in Large Margin Classifiers

.
•  Huang, B., & Jebara, T. (2007). Loopy belief propagation for bipartite maximum weight b-matching. AISTATS.
•  Huang, J. C., & Frey, B. J. (2008). Structured ranking learning using cumulative distribution networks. In NIPS.
•  Huber, M., & Law, J. (2008). Fast approximation of the permanent for very dense problems. SODA.
•  Jebara, T., & Shchogolev, V. (2006).

B-matching for spectral clustering.

ECML.
•  Jarvelin, K., & Kekalainen, J. (2002). Cumulated gain-based evaluation of ir techniques. ACM Transactions on Information Systems, 20, 2002.
•  Jonker, R., & Volgenant, A. (1987). A shortest augmenting path algorithm for dense and sparse linear assignment problems. Computing, 38, 325–340.
•  Koo, T., Globerson, A., Carreras, X., & Collins, M. (2007). Structured prediction models via the matrix-tree theorem. EMNLP.
•  Lafferty, J. D., McCallum, A., & Pereira, F. (2001). Conditional random fields: Probabilistic modeling for segmenting and labeling sequence data. ICML.
•  Le, Q., & Smola, A. (2007). Direct optimization of ranking measures. http://arxiv.org/abs/0704.3359.
•  Liu, T.-Y., Xu, J., Qin, T., Xiong, W., & Li, H. (2007). Letor: Benchmark dataset for research on learning to rank for information retrieval. LR4IR.
•  Martinez, C. (2004). Partial quicksort. SIAM.
•  McAllester, D. (2007). Generalization bounds and consistency for structured labeling. Predicting Structured Data.
•  Minc, H. (1978). Permanents. Addison-Wesley.
•  Minka, T., & Robertson, S. (2008). Selection bias in the letor datasets. LR4IR.
•  Nocedal, J., & Wright, S. J. (1999). Numerical optimization. Springer Series in Operations Research. Springer.
•  Papadimitriou, C. H., & Steiglitz, K. (1982). Combinatorial optimization: Algorithms and complexity. New Jersey: Prentice-Hall.
•  Qin, T., Liu, T.-Y., Zhang, X.-D., Wang, D.-S., & Li, H. (2009). Global ranking using continuous conditional random fields. NIPS.
•  Rigutini, L., Papini, T., Maggini, M., & Scarselli, F. (2008). Sortnet: Learning to rank by a neural-based sorting algorithm. LR4IR.
•  Ryser, H. J. (1963). Combinatorial mathematics. The Carus Mathematical Monographs, No. 14, Mathematical Association of America.
•  Sherman, S. (1951). On a Theorem of Hardy, Littlewood, Polya, and Blackwell. Proceedings of the National Academy of Sciences, 37, 826–831.
•  Taskar, B. (2004). Learning structured prediction models: a large-margin approach. Doctoral dissertation, Stanford University.
•  Taskar, B., Guestrin, C., & Koller, D. (2004). Max-margin Markov networks. NIPS
•  Tsochantaridis, I., Joachims, T., Hofmann, T., & Altun, Y. (2005). Large margin methods for structured and interdependent output variables. JMLR, 6, 1453–1484.
•  Valiant, L. G. (1979). The complexity of computing the permanent. Theor. Comput. Sci. (pp. 189–201).
•  Wainwright, M. J., & Jordan, M. I. (2003). Graphical models, exponential families, and variational inference (Technical Report 649). UC Berkeley, Department of Statistics.
•  Xu, J., & Li, H. (2007). Adarank: a boosting algorithm for information retrieval. SIGIR.
•  Zheng, Z., Zha, H., & Sun, G. (2008a). Query-level learning to rank using isotonic regression. LR4IR.
•  Zheng, Z., Zha, H., Zhang, T., Chapelle, O., Chen, K., & Sun, G. (2008b). A general boosting method and its application to learning ranking functions for web search. NIPS.

## Appendix A

For completeness we include a description of the sampling algorithm presented in . The algorithm is an accept-reject algorithm. The core idea of such an algorithm is very simple: assume we need to sample from a distribution in a given domain , but that such a task is intractable. Instead, we sample from a distribution in a superset of the original domain (in which sampling is easier), whose restriction to the original domain coincides with the original distribution: . We then only ‘accept’ those samples that effectively fall within the original domain . Clearly, the efficiency of such a procedure will be dictated by (i) how efficient it is to sample from in and (ii) how much mass of is in . Roughly speaking, the algorithm presented in  manages to sample perfect matches of bipartite graphs such that both conditions (i) and (ii) are favorable.

The reasoning goes as follows: the problem consists of generating variates ( is a match) with the property that , where is the non-negative score of match and is the partition function, which in our case is a permanent as discussed in Section 4.1. We first partition the space into , where . Each part has its own partition function . Next, a suitable upper bound on the partition function is constructed such that the following two properties hold:555See  for details.

 (P1)M∑i=1U(\Ycali)≤U(\Ycal). (P2)If |\Ycali|=1, then % U(\Ycali)=Zi=w(y).

That is, (i) the upper bound is super-additive in the elements of the partition and (ii) if has a single match, the upper bound equals the partition function, which in this case is just the score of that match.

Now the algorithm: consider the random variable

where . By (P1), , so assume . Now, draw a variate from this distribution, and if , reject and restart, otherwise recursively sample in .666Due to the self-reducibility of permutations, when we fix , what remains is also a set of permutations. We then sample . This algorithm either stops and restarts or it reaches which consists of a match, i.e., . This match is then a legitimate sample from . The reason this is the case is because of (P2), as shown below. Assuming the algorithm finishes after samples, the probability of the match is the telescopic product

 (20)

and since the probability of acceptance is , we have

 p(y)=w(y)/U(\Ycal)Z/U(\Ycal)=w(y)Z, (21)

which is indeed the distribution from which we want to sample. For pseudocode and a rigorous presentation of the algorithm, see .