Log In Sign Up

Machine Learning-powered Iterative Combinatorial Auctions

In this paper, we present a machine learning-powered iterative combinatorial auction (CA). The main goal of integrating machine learning (ML) into the auction is to improve preference elicitation, which is a major challenge in large CAs. In contrast to prior work, our auction design uses value queries instead of prices to drive the auction. The ML algorithm is used to help the auction decide which value queries to ask in every iteration. While using ML inside an auction introduces new challenges, we demonstrate how we obtain a design that is individually rational, has good incentives, and is computationally practical. We benchmark our new auction against the well-known combinatorial clock auction (CCA). Our results indicate that, especially in large domains, our ML-powered auction can achieve higher allocative efficiency than the CCA, even with only a small number of value queries.


page 1

page 2

page 3

page 4


Machine Learning-powered Iterative Combinatorial Auctions with Interval Bidding

We study the design of iterative combinatorial auctions for domains with...

Fourier Analysis-based Iterative Combinatorial Auctions

Recent advances in Fourier analysis have brought new tools to efficientl...

Deep Learning-powered Iterative Combinatorial Auctions

In this paper, we study the design of deep learning-powered iterative co...

Fast Iterative Combinatorial Auctions via Bayesian Learning

Iterative combinatorial auctions (CAs) are often used in multi-billion d...

Monotone-Value Neural Networks: Exploiting Preference Monotonicity in Combinatorial Assignment

Many important resource allocation problems involve the combinatorial as...

A Bayesian Clearing Mechanism for Combinatorial Auctions

We cast the problem of combinatorial auction design in a Bayesian framew...

Bayesian Optimization-based Combinatorial Assignment

We study the combinatorial assignment domain, which includes combinatori...

1 Introduction

Combinatorial auctions (CAs) are used to allocate multiple items among bidders who may view these items as complements or substitutes. Specifically, they allow bidders to submit bids on bundles of items to express their complex preferences. CAs have found widespread real-world applications, including for the sale of spectrum licenses (Cramton, 2013) and the allocation of TV-ad slots (Goetzendorf et al., 2015).

One of the main challenges when conducting CAs in practice is that the bundle space grows exponentially in the number of items, which typically makes it impossible for bidders to report their full value function. Practical CA designs allow bidders to report only a limited number of bids which are treated as “all-or-nothing” bundle bids by the auctioneer (see, e.g., Ausubel and Baranov, 2017). However, this number can be very small compared to the total number of bundles. For example, the 2014 Canadian spectrum auction (Industry Canada, 2013) had 106 clock rounds (where each bidder essentially submits one bid per round), followed by a second phase in which bidders were limited to submit bids on at most 500 of the possible bundles (and multiple bidders reached this limit of 500 bids). Thus, preference elicitation remains a primary problem, especially in large CAs. 55todo: 5Cite ICAs for Offshore Wind Auctions

1.1 Preference Elicitation in CAs

Researchers have addressed this preference elicitation challenge by designing bidding languages that are succinct yet expressive for specific (restricted) classes of valuation functions (see Nisan (2006) for a survey). For some applications (e.g., in procurement auctions), practitioners have also developed domain-specific bidding languages exploiting specific knowledge about the structure of the bidders’ value functions (Sandholm, 2013; Goetzendorf et al., 2015). However, in many domains, like spectrum auctions, bidders’ value functions exhibit such a rich and complex structure that they do not fall into any of the succinctly expressible valuation classes supported by the domain-specific languages proposed in the literature. Furthermore, any particular choice of a domain-specific bidding language may favor one bidder over another, which is problematic for a government-run auction which should not bias against certain participants. But, unfortunately, if one must support general valuations and guarantee full (or even approximate) efficiency, then the auction requires an exponential amount of communication in the worst case (Nisan and Segal, 2006).

To get around this difficulty in practice, the preference elicitation challenge is often addressed by using iterative combinatorial auctions

, where the auctioneer heuristically elicits information from the bidders over multiple rounds, imposing some kind of limit on the amount of information exchange. Common formats include

ascending-price auctions as well as clock auctions, where prices are used to coordinate the bidding process. In recent years, the combinatorial clock auction (CCA) has gained momentum (Ausubel et al., 2006). Between 2012 and 2014 alone, ten countries have used the CCA, raising approximately $20 billion in revenues, with the 2014 Canadian 700 MHZ auction being the largest auction, raising more than $5 billion (Ausubel and Baranov, 2017). The CCA consists of two main phases: in the initial clock phase, the auctioneer quotes (linear) item prices in each round, and bidders are asked to respond to a demand query, stating their profit-maximizing bundle at the quoted prices. In the second phase (the supplementary round), bidders can submit a finite number of bundle bids (typically up to 500). This design is meant to combine good price discovery in the clock phase with good expressiveness in the supplementary round.

In spite of the practical success of the CCA, a recent line of papers has revealed some of its shortcomings. Regarding bidding complexity, Knapek and Wambach (2012) discuss why bidding optimally in the CCA may be challenging. Janssen, Karamychev and Kasberger (2017) and Janssen and Kasberger (2015) discuss how bidders can engage in strategic behavior if they want to increase rivals’ costs or if they are facing budget constraints.

In addition to these issues with bidding complexity and incentives, another line of research has studied the efficiency of the CCA. Some experimental studies have shown that bidders may not be able to accurately respond to a demand query (which may require full exploration of the exponentially-sized value space). In particular, Scheffel, Ziegler and Bichler (2012) and Bichler, Shabalin and Wolf (2013) have shown that bidders tend to focus on a limited search space consisting of some bundles of items selected prior to the auction, and that this can cause significant efficiency losses (between 4% to 11% in their experiments).

1.2 Overview of our Contributions

To address these shortcomings of the CCA, we propose a new auction design, specifically a machine learning-powered iterative combinatorial auction. In contrast to the CCA, our auction does not use demand queries (i.e., prices) but instead asks bidders for value reports on individual bundles. While in the clock phase of the CCA, clock prices do the job of coordinating bidders towards finding an (approximately) efficient allocation, in our approach, we use an elicitation process guided by machine learning (ML) to serve this role.

In Section 3, we present the design of our new auction which consist of two separate algorithmic contributions. Our first contribution is an ML-powered QueryModule (Section 3.1) which, given a set of bundle-value pairs reported by each bidder, determines a new query for each bidder to be answered in the next round of the auction. The QueryModule consists of two key steps. First, given a set of bundle-value reports for each individual bidder, we use an ML algorithm for each bidder to compute an inferred value function for this bidder, which provides us with a prediction of this bidder’s value for any bundle in the bundle space. We then compute an efficient allocation based on these inferred valuations, and we use the information from this step to determine the next query for each bidder.

Our second algorithmic contribution is the design of the complete ML-based ICA which we call Pseudo VCG Machine Learning-based (PVML) mechanism (Section 3.2). PVML uses the QueryModule as a sub-routine in every round of the auction and ultimately determines an allocation and payments. PVML is built around two main ideas. We charge “VCG-style payments” and we allow bidders to “push” information to the auction which they deem useful for efficiency. Together, these two design features lead to good incentives in practice.

In Section 4, we provide a detailed theoretical analysis of the properties of PVML. We begin by showing how the performance of the ML algorithm, measured in terms of the learning error, relates to the performance of PVML (Section 4.1). Specifically, given a bound on the learning error of the ML algorithm, we provide a bound on the efficiency loss incurred by PVML. Furthermore, we provide a price-based interpretation of the elicitation performed by PVML. Even though the bidders only communicate with the mechanism via value reports, we can impute prices to gain insight into how bundles are implicitly priced as the auction proceeds. We then show that PVML obtains an approximate competitive equilibrium, where the approximation depends on the learning error of the ML algorithm.

We then move on to analyze standard mechanism design properties of PVML. In terms of incentives, we first show that PVML is not ex-post Nash incentive compatible. Similar to other practical CAs like the CCA, this is due to the rich dynamic strategy space of the bidders and the fact that we cannot guarantee finding the efficient allocation. However, we show that PVML is social welfare aligned which means that any beneficial manipulation a bidder finds must increase the social welfare by the same amount. Together with the fact that bidders can “push” self-selected bundle-value pairs to the auction in an initial phase, we argue that this provides PVML with “good incentives in practice.” Concretely, if bidders have certain beliefs about which bundles they should receive as part of a (highly) efficient allocation, then they can simply push those bundles in the initial phase. Afterwards, they should simply answer all value queries truthfully, to enable the mechanism to maximize social welfare (which it is designed to do).

In Section 4.3, we show that PVML satisfies individual rationality

, i.e., no bidder obtains negative utility by participating in the auction. Finally, in Section 4.4., we study whether PVML can run at a deficit or not. We show that, in principle, it may run at a deficit – although the probability of a deficit occuring depends on how much information the auctioneer elicits from each bidder (and thus, how well she can compute the Pseudo-VCG payments). We then explain that, in practice, an auctioneer who wants to guarantee the

no-deficit property can simply lower-bound each bidder’s payment by zero (albeit, at the consequence of slightly relaxing the social welfare alginment property).

While for the description of PVML in Section 3 and the theoretical analysis in Section 4, we can leave the ML algorithm unspecified, we finally instantiate it in Section 5. In principle, any ML algorithm could be used within PVML. However, a key requirement is that one can relatively quickly solve the auction’s winner determination problem (WDP) based on bidders’ inferred valuations, to compute a new allocation – and this computation is done many hundreds of times (inside the QueryModule) throughout one run of PVML. Thus, in our experiments, we limit the execution time for one such WDP computation to 1 minute. In Section 5, we first explain how standard linear regression

can be used to obtain the bidder’s inferred valuations, and how formulating the linear regression-based WDP is straightforward. Then we generalize this to non-linear machine learning models that can also capture substitutes and complements valuations – in particular, we use

kernelized support vector regression (SVR)

. We discuss SVRs with four popular kernels: Linear (which corresponds to linear regression), Quadratic, Exponential, and Gaussian, and we provide WDP formulations for all four. Using a different kernel in the SVR essentially leads to a different ML algorithm inside PVML.

In Section 6, we then provide experimental results comparing the performance of these four ML algorithms. Our main insight in this section is that the choice of the right ML algorithm used inside PVML depends on two characteristics: first, the ML algorithm’s prediction performance (measured in terms of the learning error), and second, our ability to solve the ML-based WDP problem reasonably quickly. We show that the four kernels we test differ along those two dimensions. The Exponential kernel leads to the best prediction performance, but it also results in a computationally very difficult WDP, such that we cannot solve the WDP to optimality when computing the allocation inside the QueryModule. In contrast, the Quadratic kernel only has slightly worse prediction performance, but we can formulate the corresponding WDP as a Quadratic Integer program which we can solve relatively quickly, even for large auction instances. This is why in terms of economic efficiency (our main variable of interest), the Quadratic kernel outperforms the other three kernels.

In Section 7, we then present experimental results evaluating the overall performance of PVML (using SVRs with a Quadratic kernel) and we benchmark it against the CCA. For these experiments, we employ the spectrum auction test suite (SATS) Weiss, Lubin and Seuken (2017), and we use the LSVM, GSVM and MRVM domains. We simulate the CCA with a full clock phase plus an additional supplementary round. The number of bids that bidders submit in the supplementary round is equal to the maximum number of bundle-value pairs that bidders submit in PVML, and we vary that number between 100 and 500.

Our first result is that, as one would expect, the performance of PVML depends on how well the ML algorithm can capture the structure of the domain. LSVM has a highly non-linear structure, but bidders are not interested in a large number of bundles. In this domain, the CCA achieves slightly higher efficiency than PVML with 500 queries. In contrast, in GSVM, the Quadratic kernel can perfectly capture the structure of the domain, and thus is able to generalize very well. This leads to an efficiency of 100% for PVML, even with only 100 queries, while the CCA only achieves 99.2% with 100 queries.

Finally, we test both mechanisms on the MRVM domain, which is the largest and most realistic domain, with 10 bidders and 98 goods. Here, PVML again clearly outperforms the CCA. With 500 queries, the CCA achieves an efficiency of 93.2% while PVML achieves 94.5%, which is roughly a 1.3% point improvement.

1.3 Related Work on Machine Learning and Mechanism Design

There are multiple existing strands of research connecting machine learning with mechanism design. One line of research grew out of the automated mechanism design (AMD) research agenda (Conitzer and Sandholm, 2002, 2004), aiming to use algorithms to design direct-revelation mechanisms: these are mechanisms where agents report all of their preferences upfront and the mechanism determines the outcome based on these preferences. The first approaches to AMD were based on formulating the mechanism design problem as a search problem over the space of all possible mappings from agents’ preference profiles to outcomes. These approaches were only applicable to small settings mainly because of the dimension of the preference profile space. Recent work has partly addressed this scalability issue by limiting the search to parametrized classes of mechanisms and using learning algorithms to find suitable parameter values. Dütting et al. (2015)

used discriminant-based classifiers to learn approximately strategyproof payment rules for combinatorial auctions.

Narasimhan, Agarwal and Parkes (2016) further showed how to extend these techniques to mechanisms that are not allowed to charge payments. In more recent work, Duetting et al. (2018)

have used deep learning methods to advance the design of revenue-maximizing auctions. Similar deep learning methods were also applied by

Golowich, Narasimhan and Parkes (2018) to design matching mechanisms.
The research agenda of using a learning framework to design revenue-maximizing auctions also involves several sample complexity results provided for different settings (Cole and Roughgarden, 2014; Medina and Mohri, 2014; Cesa-Bianchi, Gentile and Mansour, 2015; Morgenstern and Roughgarden, 2015, 2016; Roughgarden and Schrijvers, 2016; Balcan, Sandholm and Vitercik, 2016, 2017; Syrgkanis, 2017). Similarly to AMD, in our work we design mechanisms through algorithms. However, the main difference lies in our focus of indirect-revelation mechanisms where agents’ preferences are iteratively elicited by the mechanism.

Another important research agenda related to this paper is the one of preference elicitation in combinatorial auctions, which dates back to the early 2000s (Sandholm and Boutilier, 2006). Among the most relevant work in this agenda are the papers by Lahaie and Parkes (2004) and Blum et al. (2004) which used learning algorithms to design elicitation algorithms for specific classes of valuations. Elicitation algorithms for generic valuations based on ML were introduced by Lahaie (2011) and further developed by Lahaie and Lubin (2019). These approaches are based on using ML on bidders’ reports to find competitive equilibrium prices, i.e., prices that coordinate bidders towards demanding efficient allocations. Brero and Lahaie (2018) and Brero, Lahaie and Seuken (2019) built on these mechanisms and designed Bayesian auctions that, besides bidders’ reports, can exploit prior beliefs on bidders’ valuations to quickly determine competitive equilibrium prices. In contrast to the pre-dominant research agenda in this field, we do not use ML to directly learn or predict competitive equilibrium prices. Instead, we use ML to learn bidders’ valuations, and we only provide an implicit (internal) correspondence to approximate clearing price (but these are never shown to bidders). We use the learned valuations to determine which values should be queried from the bidders in the next round, to ultimately find a highly efficient allocation. This leads to a very different auction protocol, with different opportunities for machine learning, different challenges that need to be addressed, and different resulting properties.

2 Preliminaries

66todo: 6Think about whether the bidders’ set of bundle-value pairs should, in the preliminaries section, already have superscript t, to explain more clearly that they depend on the round of the auction. This would also emphasize already in the preliminaries section that we are studying an ICA, and not just a CA.

In this section we present our formal model. We start by introducing the combinatorial auction setting in Subsection 2.1. In Subsection 2.2, we discuss the mechanism design problem we want to solve, its challenges, and the solutions proposed in prior work.

77todo: 7Consider only using one term, either value function or valuation.88todo: 8Think about whether we want notation A,B,C in addition to the vector notation for items, to use this simpler notation (rather than vector notation), e.g., in examples.

2.1 Combinatorial Auctions

In a combinatorial auction (CA), there is a set of indivisible items being auctioned off to bidders. We let , so that and denote the index sets of bidders and items, respectively. A bundle is a subset of the set of items. We associate each bundle with its indicator vector and denote the set of bundles as . We represent the preferences of each bidder i with a value function that is private knowledge of the bidder. Thus, for each bundle represents the true value that bidder has for obtaining . We do not make any assumptions regarding the structure of bidders’ value functions. We assume that values are normalized such that the bidders have zero value for the empty bundle. We sometimes also refer to as bidder ’s valuation. We let denote the vector of bidders’ valuations and the corresponding vector where bidder is excluded.

A CA determines an allocation and charges payments to the bidders. An allocation is a vector of bundles , with being the bundle that bidder obtains under . An allocation is feasible if each item is allocated to at most one bidder; we denote the set of feasible allocations by . Payments are defined as a vector , with denoting the amount charged to bidder . We assume that bidders have a quasi-linear utility function of the form . The social welfare of an allocation , which we compactly denote as , is the sum of the bidders’ true values for , i.e. . The social welfare-maximizing (i.e., efficient) allocation is denoted as . We measure the efficiency of any allocation as . We aim for the design of mechanisms that maximize efficiency.

A CA mechanism defines how bidders interact with the auction, how the final allocation is determined, and how much each bidder has to pay. In this paper, we design a mechanism that asks bidders to report values for bundles (across different rounds of an auction). We let denote bidder ’s value report on bundle ; we often refer to as a bundle-value pair. Our mechanism will enforce that a bidder cannot make multiple reports on the same bundle. We let denote a set of bundle-value pairs reported by bidder . For notational simplicity, we say that if . We use to denote the number of bundle-value pairs in .

In general, bidders do not make a value report for all bundles in the bundle space. Therefore, given a set of reported bundle-value pairs by bidder , , we define a reported value function which monotonically extends bidder ’s individual value reports for bundles to the whole bundle space assuming free disposal (i.e., ). Thus, formally, every set of bundle-value pairs induces a different function . To avoid the double subscript notation, going forward, we simply write for .

We let denote the vector of these sets of reported bundle value pairs. Given an , we can now define the reported social welfare of an allocation as . The efficient allocation with respect to is denoted as . Without loss of generality, we only consider allocations that consist of bundles contained in .

99todo: 9Two issues with the set notation s: (1) It looks like v-hat-i-s depends on the whole profile s, while it only depends on s-i. (2) Double subscript notation for the efficient allocation.

2.2 The Vickrey-Clarke-Groves (VCG) Mechanism

We now define the well-known VCG mechanism (Vickrey, 1961; Clarke, 1971; Groves, 1973) which is the gold standard to allocate items efficiently in a CA.

Definition 1 (VCG Mechanism).

Under VCG, every bidder must make a report about its full value function, which we denote by . VCG allocates allocates items according to and charges each bidder payment


It is well known that VCG is strategyproof, i.e., it is a dominant strategy for all bidders to report their true value function, independent of what the other bidders do. This can easily be seen by considering that bidder ’s utility under VCG is equal to


Bidder cannot affect the last term , and the sum of the first two terms is equal to reported social welfare, which is maximized by the mechanism. Thus, it is dominant strategy for bidder to report his true value function. When all bidders follow their dominant strategy, VCG is efficient.

2.3 Iterative VCG Mechanisms

1010todo: 10Find a better reference (Parkes01/02??) for the statement that one does not need full value function.

VCG is often considered an impractical mechanism for CAs, in particular in domains with a large number of items, because it requires bidders to report their full value function (which is exponentially sized in the number of items). Fortunately, it has been shown that one does not always need to elicit the full value functions to determine the VCG outcome (Mishra and Parkes, 2007). Building on this insight, researchers have proposed iterative VCG mechanisms (e.g., Mishra and Parkes (2007); de Vries, Schummer and Vohra (2007)). The idea of these mechanisms is to interact with bidders over multiple rounds and, when bidders follow truthful bidding behavior (suitably defined), to only elicit enough information to determine the VCG outcome with respect to their true valuation at the end of the auction.

Intuitively, by realizing the VCG outcome, these mechanisms inherit some good incentive properties of VCG. In fact, such mechanisms support truthful bidding in ex-post Nash equilibrium (Mishra and Parkes, 2007; de Vries, Schummer and Vohra, 2007). However, given that iterative VCG mechanisms increase the strategy space (where bidders may now condition their actions on progress throughout the auction), we lose the strong guarantees of VCG based on dominant strategies.

3 The Pseudo VCG Machine Learning-based Mechanism

In this section, we introduce our new mechanism. As mentioned in the previous section, our primary design goal is to achieve high efficiency. Unfortunately, it is well known that finding the efficient allocation requires communication that is exponential in the number of items in the worst case (Nisan and Segal, 2006). Furthermore, it has been shown that you cannot even achieve a useful approximation of efficiency with less than exponential worst-case communication. Note that this implies that iterative VCG mechanisms (e.g., Mishra and Parkes, 2007; de Vries, Schummer and Vohra, 2007) also require exponential communication in the worst case and are thus impractical even in medium-sized domains.

To obtain a practical CA, we design a mechanism that, like iterative VCG, interacts with bidders over multiple rounds, but that imposes a strict limit on the information exchanged between each bidder and the auction. Note that the amount and the type of information being exchanged depends on the auction format and thus the type of queries that are used. Many iterative CAs use demand queries where bidders are shown ask prices and have to report their profit-maximizing bundle at these prices. The amount of information exchanged per demand query depends on the dimensionality of the ask prices. For example, the CCA uses linear prices (i.e., one price per item), which, combined with a bound on the number of rounds, ensures practicality. Note that, due to the result by Nisan and Segal (2006), this also implies that the CCA cannot provide efficiency guarantees.

In our mechanism, the information exchanged consists of a small set of bundle-value pairs from each bidder, and the size of this set is limited via a parameter of our mechanism. Of course, due to Nisan and Segal (2006), this implies that our mechanism also cannot provide useful efficiency guarantees. However, our goal is to design a mechanism that maximizes empirical efficiency in realistic CA domains.

Intuitively, a mechanism that wants to maximize empirical efficiency but is constrained on information exchange should elicit the “most important” information from each bidder. However, in an iterative mechanism, identifying the “next most-useful query” is not an easy task because it requires reasoning about the incremental value of the missing information given what has already been elicited. To this end, there are three basic approaches. First, if enough structure regarding bidders’ value functions can be assumed ex ante, then the auctioneer can use this structure to generalize one piece of information from bidders to a large part of the bidders’ value functions. However, in this work, we allow for general valuations such that our mechanism does not rely on any critical structural assumptions.

Second, instead of the auctioneer performing the generalization task by exploiting structural assumptions, the bidders can do it themselves by explicitly providing information statements about their whole value function. The CCA follows this principle by asking bidders demand queries in each round of the clock phase. An answer to a demand query does not only provide the auctioneer with information on one bundle, but it is simultaneously a statement regarding the bidder’s whole value function. The auctioneer can then use these “global information statements” to identify the next query. For example, the CCA computes the next query via a simple price update rule where prices on over-demanded items are increased by a fixed percentage (Ausubel and Baranov, 2017).

In this work, we propose a third approach to perform the generalization task, using machine learning (ML). The idea is to train an ML algorithm for each individual bidder on that bidder’s value reports to generalize to the whole bundle space, i.e., to infer a value for each bundle the bidder has not evaluated yet. For example, consider a bidder who reported value 1 for bundle and value for bundle . To build some intuition, consider simple linear regression, which in this example would predict value 9 for bundle . Of course, linear regression can only learn additive value functions as it only has one coefficient per item. In Section 5, we present our general ML framework and explain how non-linear ML algorithms (which can capture substitute and complements valuations) can be employed in our mechanism. Equipped with an ML algorithm, we can take the bundle-value reports obtained from each bidder, feed them to the ML algorithm to generalize to the whole bundle space. As in approaches 1 and 2, this provides the auctioneer with a statement about the whole value function which can then be used to compute the next query. In Section 3.1, we describe in detail our machine learning-powered “QueryModule” which takes as input a set of bundle-value pairs from each bidder and determines a new query for each bidder.

1111todo: 11Here, add a SHORT PARAGRAPH WITH PROS and differences to approach 1 and 2.

In Section 3.2 we present our full ML-powered mechanism, which uses the QueryModule as a sub-routine in every round of the auction, and which ultimately determines the final allocation and payments. Recall that, due to the result by Nisan and Segal (2006), we cannot provide efficiency guarantees while maintaining practicality, which implies that we cannot determine the VCG outcome. While this implies that we cannot achieve the good efficiency and incentive guarantees of iterative VCG mechanisms, we nevertheless follow the design principles of VCG to obtain a mechanism that provides bidders with “good incentives in practice.” Concretely, we charge “VCG-style payments” and we allow bidders to “push“ information to the auction which they deem useful for efficiency. Together, these two design features lead to good incentives in practice, as we will show in detail in Section 4.

3.1 Machine Learning-powered Query Module

Figure 1: Schematic representation of how the query module works.
1212todo: 12The next two paragraphs seem a bit repetitive. Check if ok or not.1313todo: 13Update the description of the algorithm. Also, best to not hardcode the line references ;-)

In this section, we describe in detail our QueryModule (see Figure 1 for a schematic view). The module takes as input a set of bundle-value pairs from each bidder . Then, for each bidder a ML algorithm is trained based to infer a value function .111In Section 5, we first instantiate using linear regression and then generalize it to non-linear learning models. The inferred value functions are then used by the optimization algorithm to compute an efficient allocation with respect to the inferred valuations. The module assigns each bidder a new query given by the bundle she obtains under this allocation.222To prevent a bidder from being assigned a bundle she has already evaluated, we restrict the set of allocations considered when determining a new query for each bidder.

1 function NextQuery;
Inputs: ML algorithm ; Vector of sets of bundle-value pairs ;
2 foreach bidder  do
3       ;      Estimation Step: infer valuation for each bidder using ML algorithm
5 end foreach
6Determine ;      Optimization Step (based on inferred valuations)
7 foreach bidder  do
8       if  then
9             ;
11       else
12             ;
13             Determine ;      Optimization Step (with restrictions)
14             ;
16       end if
18 end foreach
19Output vector of queries ;
Algorithm 1 Machine Learning-powered Query Module

Algorithm 1 provides a detailed description of our query module. Formally, we represent our query module as a function NextQuery which takes as input a machine learning algorithm and a set of bundle-value pairs from each bidder . As we will describe in Section 3.2, our mechanism calls our query module on different subgroups of bidders called economies. To emphasize this aspect, in Algorithm 1 we denote the set of bidders as (instead of ). Our algorithm begins with the “Estimation Step”: for each bidder the ML algorithm is trained based on the bundle-value pairs to infer a value function (Line 3). Then, for each bidder our algorithm determines a set consisting of those feasible allocations that do not assign bidder  a bundle she has already evaluated in (Line 6). In the “Optimization Step” an optimization algorithm is evoked to determine the allocation in achieving the highest social welfare according to (Line 7). The algorithm assigns each bidder the new query (Line 8). Once a new query has been assigned to each bidder  in , Algorithm 1 outputs the vector of queries .

3.2 The PVML Mechanism

1414todo: 14Introduce the opportunity to push bundle-value pairs in the follwoing paragraph. Following Cite Chapter 10 from CA book, we call these “pushed bundle-value pairs.”1515todo: 15Afer introduction push bundle-value pairs, note that this is similar to the idea of pushing allocations in Nisan/Ronen. Here is some of the old text we had: "To motivate truthful reports, Nisan and Ronen (2007) argued that VCG based mechanisms should include a second round where each bidder observes the allocation the mechanism is about to implement and, in case, propose a new allocation she considers more efficient. The mechanism implements the allocation with highest reported social welfare among the one it had determined and those proposed by bidders."

In this subsection, we describe our PVML mechanism. PVML uses the query module introduced in Section 3.1 to determine a highly efficient allocation and charge “VCG style payments”. These payments are obtained by charging each bidder the difference between the overall value realized by the other bidders in an allocation elicited excluding bidder and the one they realize in the final allocation. We call the group of all bidders other than bidder ’s marginal economy – which differentiates from the main economy consisting of all bidders.333The idea of employing multiple elicitation runs in main and marginal economies in an auction was firstly proposed by Ausubel (2006) to design an iterative VCG mechanism that allocates multiple heterogeneous commodities. As we will see in Section 4, charging these VCG-style payments while allowing bidders to submit self chosen bundle-value pairs motivates bidders to report true values throughout the auction.

Parameters: ML algorithm ; maximum # of queries per bidder ; # of initial queries ;
1 Each bidder submits up to self-chosen bundle-value pairs ;
2 Ask each bidder to report his value for randomly chosen bundles and add them to ;
3 Let denote the initial reports for the main economy;
4 For each bidder , let be the initial reports for ’s marginal economy;
5 Initialize round counter: ;
6 while  do
7       ;
8       Generate queries for the main economy: NextQuery ;
9       Generate queries for each bidder ’s marginal economy: NextQuery;
10       Send generated queries to bidders and ask for corresponding values;
11       Let denote all reported bundle-value pairs obtained in Step 10 and let ;
12       Let denote the reported bundle-value pairs obtained in Step 10 for bidder ’s marginal economy and let ;
14 end while
15Determine allocation , where ;
16 Charge each bidder payment
17 Output allocation and payments ;
Algorithm 2 Pseudo-VCG Machine Learning-based (PVML) Mechanism

Algorithm 2 provides a formal description of PVML. The mechanism is parametrized by a machine learning algorithm that will be given as input to the function NextQuery, a maximum number of value reports that it is allowed to ask each bidder, and a maximum number of value reports that can be selected by a bidder in the first stage of the auction. When the auction begins, the mechanism asks each bidder to report self-chosen bundle-value pairs (Line 1) and obtains the remaining reports by asking her values for randomly-selected bundles (Line 2). The set of bundle value pairs obtained from each bidder is denoted as . PVML uses these bundle-value pairs to initialize vector of reports, one related to the main economy (Line 3) and one for each marginal economy (Line 4). Then, while the mechanism is allowed to ask up to queries to any bidder without violating the query budget , the following procedure is iterated: First, the mechanism invokes the function NextQuery on the value reports corresponding to the main economy (Line 8) and on the ones corresponding to each marginal economy (Line 9).444Note that two different calls of function NextQuery may assign the same query to the same bidder. Thus, the overall number of queries assigned in Line 8 and 9 may not be the same across bidders. To let PVML assign each bidder the same number of queries at each round, we equalize queries by iteratively calling the function NextQuery on the vector of reports related to the main economy, discarding those queries assigned to bidders that have already been assigned the maximum number of queries. All the queries generated in Line 8 and 9 are sent to the bidders that are asked to report the corresponding values (Line 10). The new vector of reports obtained is integrated in the set of queries corresponding to the main economy (Line 11). Each vector or reports corresponding to the queries generated for a marginal economy in Line 9 is integrated in the reports for this economy (Line 12). When the iterations stop, PVML determines its final allocation and payments: The final allocation is the value-maximizing allocation given all the reports obtained in the elicitation for the main economy (Line 14). The payment charged to each bidder is given by the difference between the overall value realized in the optimal allocation for the values elicited in his marginal economy and the one the other bidders realize in (Line 15).

1616todo: 16Add footnote that due to the argmax, in the implementation, we need tiebreaking, and we always break ties deterministically in the same order.
Remark 1 (Answering Value Queries with Upper and Lower bounds).

Note that in PVML bidders need to report exact values for the bundles queried in Line 10 of Algorithm 2. However, in practice it may be easier for bidders to specify bounds on bundle values than to determine such values precisely (see, e.g., Parkes, 2006). In Brero, Lubin and Seuken (2018) we have introduced a modified machine learning-based elicitation algorithm that works when bidders report upper and lower bounds instead of exact values. Via simulations we have shown that our ML-powered elicitation algorithm determines highly efficient allocations even under these less informative reports. A new PVML version based on this algorithm can be designed in future work.

4 Theoretical Analysis

In this section, we analyze which theoretical properties PVML satisfies.

4.1 Learning Error and Elicitation Guarantees

The prediction performance of an ML algorithm is usually assessed via its learning error. Formally, for a bidder , we define the learning error in a bundle as the absolute value of the difference between the bidder’s true value and the inferred value for the bundle , i.e.: . Of course, in practice, an auctioneer cannot evaluate the learning error because she does not have access to the true valuations. However, she can evaluate the ML algorithm using prior auction data. In general, the better the ML algorithm captures the domain, the smaller the learning errors can be expected. In Section 6, we evaluate the learning error of four different ML algorithms and show how they depend on the richness of the ML model used.

In this section, we still leave the ML algorithm unspecificied to derive theoretical properties that hold for any ML algorithm. We show how the performance of the ML algorithm, measured in terms of the learning error, relates to the performance of PVML. Specifically, given a bound on the learning error, we first derive a bound on the efficiency of PMVL, and then we show how we can impute prices to obtain an approximate competitive equilibrium.

4.1.1 Bounding the Efficiency Loss

First we use the learning error to bound the efficiency loss of PVML. Consider the QueryModule described in Algorithm 1. In Line 1, we compute , i.e., the efficient allocation with respect to the inferred valuation profile We then use this allocation in Line 1 to assign a new query for each bidder (unless the bidder has already reported a value for the corresponding bundle). Thus, at the end of the QueryModule, PVML ensures that all bundles contained in have been queried and will ultimately be used to compute the final allocation. This implies that the efficiency of PVML can only only be (weakly) higher than the efficiency of , assuming that all bidders only make truthful bundle-value reports. Thus, a bound on the efficiency loss for any specific translates into a bound on the efficiency loss of PVML.

1717todo: 17Add V(a) to preliminaries, and slightly update proof here.
Proposition 1.

Let be an inferred valuation profile. Let be an efficient allocation w.r.t. to , and let be an efficient allocation w.r.t. the true valuation profile. Assume that the learning errors in the bundles of these two allocations are bounded as follows: for each bidder , and , for . Then the following bound on the efficiency loss in holds:


We add and subtract and to , obtaining


Given that is a social welfare-maximizing allocation under , the term in (5) cannot be positive. Inequality (4) follows considering that any real number cannot be greater than its absolute value. ∎

In words, Proposition 1 shows us that the efficiency loss in is bounded by the overall learning error in the two allocations and (normalized by the maximum social welfare). While the efficient allocation is not known to the auctioneer, she does know at each round of PVML. This provides some motivation for the design of our QueryModule. Consider the allocation which Algorithm 1 determines in Line 5. The bound from Proposition 1 increases in the learning errors in each bidder’s bundle . This motivates Line 8 of Algorithm 1, where we query every bidder the bundle ; if the allocation remained stable in the next round, there are no more learning errors due to that contribute to the bound (when using an ML algorithm that is accurate on the training data). If a bidder has previously reported a value for bundle , then this means that there are no “obvious” queries to ask this bidder. Consequently, Algorithm 1 then enters the “else-branch” to determine a new allocation where the winner determination algorithm is restricted to only allocate a bundle to this bidder which he has not reported a value for yet.

4.1.2 Learning Error and Imputed Approximate Clearing Prices

1818todo: 18Is this the right title for this section, given that we do not talk much about clearing prices, but talk mostly about CE?

Recall that in PVML, bidders submit bundle-value reports, while most prior work on iterative CAs uses prices for elicitation. We now show how we can obtain a price-based interpretation of the elicitation performed by PVML’s QueryModule. In particular, we show how we can impute prices that are implicit in the elicitation. Given a bound on the learning error of the ML algorithm, we then provide a measure on the quality of these imputed prices. Concretely, we measure the quality of these prices by using the concept of competitive equilibrium.

To define a competitive equilibrium, we introduce a very general concept of prices (allowing for non-anonymous bundle prices). We let denote the price profile, where each is bidder ’s price function, with denoting bidder ’s price for any given bundle . Given this, we can now define a competitive equilibrium (CE).

Definition 2 (Competitive equilibrium).

Given prices , we define each bidder ’s demand set as the set of bundles that maximize her utility at : . Similarly, we can define the seller’s supply set as the set of allocations that are most profitable at : . We say that prices and allocation are in competitive equilibrium if and, for each bidder , .

It is well known that any competitive equilibrium allocation is efficient (Mas-Colell, Whinston and Green, 1995, 16.C-D). Prior work on iterative CAs has exploited this property. For example, the iterative VCG mechanisms by Mishra and Parkes (2007) and de Vries, Schummer and Vohra (2007) iteratively update prices until a CE is found.555More concretely, they find specific CE prices called universal competitive equilibrium (UCE) prices, which contain all the information necessary to compute a VCG outcome. This approach is motivated by the fact that any auction that finds an efficient allocation must reveal CE prices (Nisan and Segal, 2006). However, in the worst case, this may require an exponential amount of communication (potentially quoting a different price for each bundle).

Recall that in PVML, we limit the amount of information exchanged (via the query cap). Thus, due to the result by Nisan and Segal (2006), we cannot guarantee finding a CE. In fact, PVML does not even use prices to interact with bidders (in contrast to the CCA or iterative VCG mechanisms). However, at each round of the auction, we can impute prices based on the inferred valuations in that round. This provides insight into how bundles are being implicitly priced in each round of PVML.

1919todo: 19Extend the following to the full polytope.

Concretely, if is the inferred valuation profile with respect to all bundle-value pairs reported so far, then one can impute a price profile for the current round.666Of course, is the seller-optimal imputed price vector. But it is not the only price vector one can impute from . Instead, there is a polytope of imputed prices for which the following proposition holds. We will add more details on this in a future version of this paper. To measure the quality of this imputed price profile, we use the concept of approximate competitive equilibrium prices (see, e.g., Brero and Lahaie, 2018). Specifically, given a bound on the learning error of the ML algorithm, we can bound the degree of approximation in the equilibrium price profile.

2020todo: 20Improve the proof for the following proposition.
Proposition 2.

Let be an inferred valuation profile and be an efficient allocation. Assume that the learning errors are bounded as follows: for each bidder , and . Then, we need to inject at most into the market to induce the bidders and the seller to trade the allocation at prices , i.e., is a -approximate competitive equilibrium price profile.


The transfer that should be made to the seller to trade at prices is , while the one that should be made to each bidder is . After summing up all these transfers we obtain a total transfer


Note that, by adding and subtracting to the second term in Equation (6) we have that . We can then use our assumptions to conclude that . ∎

Proposition 2 provides us with a measure on the quality of the price profile . Concretely, it tells us how close to clearing this price vector is as a function of the learning error of the ML algorithm.777Note that, starting from the approximately-clearing price profile , we could now derive a bound on the efficiency loss in . However, it would be the same bound we have already proven in Proposition 1. We want to emphasize that these imputed prices are only implicit when PVML is run. Importantly, they inherit the structure of , which can be very complex, depending on the ML algorithm used. In particular, the prices will in general be non-anonymous, and if we use high-dimensional (non-linear) ML algorithms, then they will also be high-dimension bundle prices. Note that this implict high-dimensional price structure enables PVML to find an approximate CE (where the approximation depends on the learning error of the ML algorithm) while approaches based on linear prices may severely limited. 2121todo: 21double check this last sentence, and improve wording.

Introducing this price-based interpretation of our QueryModule allows us to explain how our mechanism is related to the work by Lahaie and Parkes (2004) who were among the first to establish a theoretical connection between preference elicitation in CAs and machine learning. In this prior work, they proposed an iterative ML-based elicitation paradigm which also uses inferred valuations to drive the elicitation process. However, while PVML is based on value reports, their algorithm critically requires demand queries (i.e., it communicates ask prices to bidders in every round). The advantage of their approach is that it guarantees finding a competitive equilibrium. However, due to the result by Nisan and Segal (2006), if their approach was applied in a general setting, it would require communicating exponentially-sized prices to the agents in every round, which makes it impractical in such settings.

In contrast to the approach by Lahaie and Parkes (2004), the CCA is designed with practical applications in mind (like PVML). A guiding pricinple underlying the clock phase of the CCA is that it aims to find approximate CE prices. However, as a practical mechanism, it cannot use exponential communication; instead, it uses linear prices and a limited number of rounds. Thus, due to Nisan and Segal (2006), it cannot guarantee finding a true CE. Note that the supplementary round of the CCA (allowing bidders to submit up to 500 bundle-value pairs in one final round) is designed to address the potential inefficiencs that remain at the end of the clock phase (e.g., due to using linear prices that may be out of equilibrium). Note that both, PVML and CCA are practical auction designs, but they restrict the amount of information exchanged in different ways. Furthermore, while the CCA explicitly aims to find an approximate CE by using demand queries, PVML can be interpreted as doing so implicitly by using an ML algorithm on value reports.

4.2 Incentives

We now analyze the incentive properties of PVML. Specifically, we show how charging the VCG-style payments of Equation 3 while allowing bidders to push some bundle-value pairs at the beginning of the auction motivates bidders to follow truthful strategies, which we define as follows:

Definition 3 (Truthful Strategy).

We say that a bidder is truthful under PVML if, when a bidder adopts this strategy during the auction, he

  • always reports his true values for the bundles explicitly queried by PVML, and

  • he only pushes bundle-value pairs with .

As described in Section 4.1.1, PVML is only guaranteed to find highly efficient allocations when bidders report their values truthfully (assuming that the ML algorithm accurately captures bidders’ valuations). Thus, we want to provider bidders with good incentives to follow a truthful strategy. Unfortunately, as shown by the following proposition, PVML allows a bidder to increase her final utility by misreporting some of her values, even when the other bidders are truthful.

2222todo: 22Think about whether to talk about ex-post Nash IC here, or not.
Proposition 3.

Under PVML, a bidder may benefit from misreporting her values, even when the other bidders are truthful.


To show this result, we need to carefully execute one run of PVML (over multiple rounds) for one specific auction instance. Consider a setting with 2 bidders and 2 items. We use PVML with linear regression, which in this setting estimates 2 coefficients (one per item). The PVML parameters are set as follows: and . Bidder ’s true values are , , and bidder ’s ones are , .

Implicitly, PVML assumes a report from both of zero for the empty bundle. Additionally, assume that in Line 1 of Algorithm 2, bidder truthfully reports . Assume that in Line 1 bidder  truthfully reports . After the initialization in Lines 3 and 4, we have: , . The valuations inferred in the Estimation Step of the query module are: and , and , and . Under this inference, bidder is assigned query in both the main and bidder ’s marginal economy, while bidder is assigned query in both the main and bidder ’s marginal economy (assuming ties are broken in favor of the first item). If bidders are truthful, in Line 11 the two value reports and are included in the corresponding sets of bundle-value pairs. When the auction ends, bidder 1 is allocated bundle and charged , with utility equal to .

If bidder  had reported , the valuation inferred in the Estimation Step of the query module would have been and , and he would have been assigned query in the main economy, obtaining this bundle in the final allocation for a payment equal to . Then, his utility would have been . ∎

Remark 2 (Robustness Against Strategic Manipulation in Practice).

While PVML is not robust against manipulations, we note that finding a beneficial manipulation of the kind described above may be very difficult for bidders. Indeed, if we look again at the proof, we notice that bidder 1 can only successfully perform his manipulation because he has perfect information about the current state of the auction (all reported bundles and the inferred valuations) and because he knows which values bidder 2 is going to report. To make PVML more robust to strategic manipulations in practice, we suggest prohibiting bidders from communicating with each others during the auction (as is common in practical auction designs). Furthermore, in Line 10 of the PVML mechanism, we suggest sending the list of new queries to each bidder as an un-ordered list of queries, such that a bidder cannot deduce which queries belong to the main or marginal economies, respectively. We argue that, from a practical perspective, this makes it even harder for a bidder to find a beneficial manipulation because it is now very difficult for a bidder to estimate the impact of any manipulation. This idea is similar to the one presented in Parkes (2001) and, as discussed by Parkes (2001), it can also hinder collusion or spiteful behaviors.

Note that allowing bidders to push bundle-value pairs in the initial round of PVML makes the manipulation described in the proof of Proposition 3 unnatural. Instead of misreporting his value for bundle to ultimately be queried and allocated bundle , bidder 1 could just push bundle-value pair in the initial round, and then report truthfully afterwards. In fact, this ability to push bundle-value pairs is an important design feature of PVML, as it makes many manipulations unnatural. We argue that this design feature of PVML together with the VCG-style payment rule, leads to the good incentives in practice. To make this notion more formal, we now first introduce some new notation.

We denote as a generic strategy for bidder , determining the behavior of the bidder at any point throughout the auction (which of course depends on his valuation and any other information available to the bidder). We let denote the bidders’ strategy profile. We use to denote a truthful strategy, i.e., a strategy where bidder always reports truthful values, and we let denote the corresponding truthful strategy profile. A CA mechanism is defined as follows: over strategy profiles , where outputs the allocation, and outputs the payment profile. With this we can now define the following property.

Definition 4 (Social Welfare Alignment).

A mechanism is social welfare aligned if, for all bidders , given a truthful strategy profile , for any strategy , the following holds:

The following result is now straightforward.

Proposition 4.

PVML is social welfare aligned.


Given PVML mechanism , by plugging in the payment formulation of PVML, the utility of each bidder , when the other bidders follow a truthful strategy profile , can be written as


where . Note that, when the other bidders are truthful, bidder cannot affect . Thus, PVML is social welfare aligned.888Note social welfare alignment is a property that is satisfied, not only by PVML, but by a large class of mechanisms. For example, all VCG-based mechanisms as introduced by Nisan and Ronen (2007) are social welfare aligned.


Now that we have shown that PVML satisfies social welfare alignment, we have all pieces in place to argue that PVML provides bidders with good incentives in practice. By “good incentives in practice” we mean that a bidder should follow the following simple strategy: (a) in the initial phase, push bundles you are interested in winning and that you think you have a chance of winning, (b) only make truthful value reports. If the query cap for the initial round is sufficiently large (e.g., 50-100), then in practice, bidders would have a lot of opportunity to provide (push) their initial knowledge to the auctioneer.

In this argument, we take as a baseline the benchmark where PVML simply queries bidders randomly in the initial round and where bidders answer all queries truthfully. There are two cases to consider. First, the simple case, when a bidder does not have any knowledge or belief that he can manipulate in a way such as to increase the efficiency of the final allocation compared to the baseline. In this case, it follows from the fact that PVML is social welfare aligned that the bidder is best off to simply report truthfully.

For the second case, assume the bidder has knowledge (or a belief) about which allocations could lead to a better social welfare than the baseline. Then the bidder could try to execute a sophisticated manipulation (with the goal of getting PVML to eventually implement that allocation). It would be better if the bidder could directly push this allocation to the auctioneer and be truthful afterwards. However, in practice, it is unlikely that bidders will be able to identify (or form beliefs about) about complete allocation (which requires an assignment of one bundle per bidder) with higher social welfare than the one PVML would determine by default, while it is more reasonable to assume that bidders can form beliefs regarding which bundles they will likely receive as part of highly efficient allocations. Thus, by letting bidder push those bundles to the mechanism, the mechanism can do the job of figuring out the remaining piece of the allocation (and it is designed to do this well). This provides the bidder with the incentive to push those bundles and report truthfully afterwards.

2323todo: 23Think about adding a Footnote on adding pushing allocations. Or perhaps not, because too impracticel. Especially for Management Science.2424todo: 24Add a remark at the end of the section that you could add an optional step in the mechanism that lets bidders state extra bundle value pairs in every round, so they can reveal what they want to get if they realize it as they go along. Note: if you add it only to the main economy you retain social welfare alignment, but there is a big opportunity for players to collude in order to improve their payments. Instead you probably want to add it both main and marginal econmies which breaks social welfare alignment (using a strategy that is very unrealistic). We don’t do it because we want to keep social welfare alignment, but as a practical measure it might be something you want to do.2525todo: 25Cut this??? 14. Prop: Any SWA aligned mechanism that, under truthful behavior is guaranteed to find the efficient allocation, is ex-post Nash IC.

4.3 Individual Rationality

A mechanism is individually rational if each bidder’s payment is less than or equal to the bidder’s reported value for his final allocation. We can show:

Proposition 5.

PVML satisfies individual rationality.


We show that, for each bidder , . From the definition of the PVML payment rule this is equivalent to . This holds because is optimized over the query profile that includes used to compute .

4.4 No-Deficit

2626todo: 26For MS: Think about adding a subsectin on revenue, or adding revenue content into the no-deficit subsection. Note, I removed the sentence that we achieve more revenue than the CCA, because it does not seem to be true anymore.2727todo: 27For MS: revise this paragraph to give it a more positive tone.

Ideally, a mechanism stipulating transfers between its participants and the center should not run a deficit. However, PVML (as defined in Section 3) does not guarantee the no deficit property. From Equation (3) we note that each payment is expected to be positive because the allocation is derived as an optimal allocation for the marginal economy excluding bidder . But it may be the case that the allocation happens to achieve higher reported social welfare with respect to the setting excluding bidder than . When this happens, our mechanism may run a deficit.

Although a deficit violation is formally possible in PVML, we did not observe observe any in the experiments we describe in Section 7 (when sufficiently many queries are allowed). However, for a practical implementation of PVML, most auctioneers would likely want a guarantee that the mechanism does not run a deficit. To obtain this guarantee we can simply lower bound each bidder’s payment by zero (or by a reserve price), i.e., we charge each bidder a payment equal to . Note, however, that lower-bounding the bidders’ payments this way implies that the resulting mechanism is no longer (formally) social welfare-aligned. If the auctioneer chooses a sufficiently large number of queries, this violation of social welfare alignment is likely to be negligible for incentives in practice.

5 Instantiating the Machine Learning Algorithm

So far, our presentation of PVML has been agnostic regarding which particular ML algorithm to use in the elicitation module. However, this choice is very important because it determines not only the quality of the queries identified by Algorithm 1, but also whether running this algorithm is computationally practical. Indeed, each time the module Elicit is called, the mechanism may need to determine up to social welfare-maximizing allocations for the inferred valuations, each time under different constraints. In general, determining each of these allocations may require evaluating exponentially many allocations, and the evaluation of each allocation requires applying once per bidder to derive each . However, if the learning model exhibits useful structure, we can exploit this structure when searching for the social welfare-maximizing allocations.

In this section, we present different learning models that can be integrated into our mechanism while keeping its computations practical. In Section 5.1, we start from the simple linear regression model. While computationally convenient, this learning model cannot capture complementarities between items, which prevents Algorithm 1 from inferring highly efficient allocations in settings where such complementarities are important. In Section 5.2 we introduce more expressive learning models, i.e., learning models able to capture more complex valuations. We show how our elicitation can be maintained computationally practical even under these new models.

5.1 Linear Regression

In linear regression, each inferred value function has the linear structure


where is the weight vector corresponding to .999Here we do not introduce a bias term. This is consistent with assuming that our bidders always value zero the empty bundle. Note that, given a weight vector , each represents bidder ’s inferred value for item . A first, simple approach to determine

is to interpolate bidder

’s reported values

. We can then use a standard squared loss function

to quantify the interpolation error between observation and prediction , and choose our weight vector as


Note that this simple approach does not provide a full characterization of and, consequently, of bidder ’s inferred valuation. We then add the extra term to the objective in (9), obtaining a convex problem. This technique is generally called Tikhonov regularization (Tikhonov and Arsenin, 1977), and it biases the inference towards valuations with low weights . This new learning model is called regularized linear regression and determines the weight vector as


where defines the tradeoff between interpolation accuracy and regularization. Note that regularized linear regression avoids inferring unnecessary high values for items that are not contained in any bundle evaluated by bidder .

When valuations are inferred via regularized linear regression, the optimization problem to determine can be formulated as an integer programing problem (IP). The IP has boolean variables , each denoting whether bidder should get item under allocation , and feasibility constraints enforcing that each item is not allocated more than once:


To limit this search problem to the allocations of the set defined in Line 10 of Algorithm 1, it is sufficient to add an integer cut for each bundle in . While integer programming problems are NP-hard, using branch and bound algorithms (Land and Doig, 1960) as implemented by modern IP solving softwares such as CPLEX (CPLEX, 2019) allows us to solve Problem (11) in few milliseconds even for large auction instances with 98 items and 10 bidders.

Despite being computationally very convenient, linear regression models have a major drawback, i.e., they cannot capture valuations where items are complements or substitutes.101010Under linear regression models, the inferred value bidder has for bundle is always additive as it is given by the sum of the inferred values for the items contained in (see Equation (8)). In the next section, we introduce a learning model that generalizes linear regression and allows to capture a broader class of valuations.

5.2 Support Vector Regression

Support vector regression (SVR) is a learning model that allows for non-linear inference while maintaining the computations in PVML practical. In this subsection we present the most important properties of SVR. We defer to Smola and Schölkopf (2004) for a detailed introduction.

To infer non-linear valuations, SVR algorithms project our bundle encodings in into a high (possibly infinite) dimensional feature space . This projection is determined via a mapping function that is a parameter of the learning model. Each valuation function is then derived via linear regression in the feature space as


where . The weight vector minimizes a potential similar to the one in (10), with the important difference that the squared loss is replaced by the -insensitive loss , where is a parameter of the model.111111Note that the -insensitive loss is null when the interpolation error is smaller than , thus inducing looser penalties. As we will discuss below, the -insensitive loss allows to maintain the representation of the inferred valuation succinct. In standard machine learning applications, this is useful to speed up each evaluation . In our application, the -insensitive loss allows to maintain our mechanism computationally practical. We can now formulate the learning problem under SVRs as follows:


When the dimensionality of the feature space is low, can be determined using standard simplex algorithms, as for linear regression. However, SVR algorithms may involve high dimensional feature spaces, meaning that it is often impractical to determine via its weight vector. In this scenario, it is convenient to derive via the dual version of the learning problem presented in (13), which is formulated in pairs of variables and ; these variables are the Lagrange multipliers of the two constraints and , respectively.


Once the optimal and are determined, the inferred valuation can be formulated as


where the function is commonly called kernel function, and it implicitly computes the scalar product of and in the feature space. When the kernel function can be evaluated via closed formulas, SVR algorithms derive non-linear valuation functions while avoiding computations in high dimensional feature spaces. Once a kernel function is selected, the optimization problem can be formulated as:


The kernel functions commonly used belong to the following two classes (Williams and Rasmussen, 2006, chapter 4):

  • dot-product kernel functions , and

  • radial basis kernel functions (RBF kernels) .

In Appendix A, we present the integer programming formulations of Problem (16) for dot-product and RBF kernels. In our application we consider three kernel functions (apart from the linear one) selected based on two criteria: 1. the expressivity of the corresponding learning model (which is determined by the implicit feature mapping ), and 2. the complexity of the corresponding instantiation of Problem (16).

The first kernel function is the Gaussian kernel, which is commonly used in the machine learning literature:

Definition 5 (Gaussian Kernel).

A Gaussian kernel is a kernel function of the form


where is a non-negative parameter.

The Gaussian kernel is an RBF kernel with the important property that its induced learning model is fully expressive, i.e., it can potentially capture any valuation function a bidder may have.

The second kernel function we consider is the Exponential kernel, which is also fully expressive but, unlike the Gaussian one, is a dot-product kernel.

Definition 6 (Exponential Kernel).

An Exponential kernel is a kernel function of the form


where is a non-negative parameter.

Last, we consider the Quadratic kernel:

Definition 7 (Quadratic Kernel).

A Quadratic kernel is a kernel function of the form


where is a non-negative parameter.

The Quadratic kernel is not fully expressive; still, it allows to formulate Problem (16) as a quadratic programming problem with boolean variables, which can be practically solved via branch and bound methods (Lima and Grossmann, 2017). As discussed in Appendix A, we can keep the IP formulations of Problem (16) succinct using a large when inferring each . However, this may need to be too large to maintain our computations practical, which makes Quadratic kernels very appealing.

6 Experiments I: Optimizing the Machine Learning Algorithm

In order to evaluate PVML, we need to identify the kernel and parameters that work well for the machine learning algorithm. Before evaluating the full mechanism in the next section, we here perform a series of experiments to identify optimal settings.

6.1 Setup

In order to run these experiments we need data with which to exercise the mechanism. The allocation of spectrum is one of the most important applications of CAs. We therefore adopt the allocation of spectrum for our experimental evaluation. To do this, we employ the Spectrum Auction Test Suite (SATS) version 0.6.4 (Weiss, Lubin and Seuken, 2017), which allows us to easily generate thousands of auction instances on demand. SATS gives us access to each bidder’s true values across all bundles, and it enables us to implicitly (without enumeration) compute an efficient allocation with respect to these full value profiles using succinct MIP formulations. This is important, as it enables to to report the efficiency of mechanisms with respect to a gold standard counter-factual calculation of the total social welfare obtainable in the domain. We tested our approach on three of SATS’ value models across a range of complexity. We describe each in turn below:

  • The Global Synergy Value Model (GSVM) (Goeree and Holt, 2008) generates medium-sized instances with 18 items and 7 bidders. GSVM models the items (spectrum licenses) as being arranged in two circles. Depending on her type, a bidder may be interested in licenses from different circles and has a value that depends on the total number of licenses of interest. GSVM also includes a “global” bidder with interest in two thirds of the total licenses.

  • The Local Synergy Value Model (LSVM) (Scheffel, Ziegler and Bichler, 2012)

    also generates medium-sized instances with 18 items and 6 bidders. In LSVM the items are placed on a two-dimensional grid, and a bidder’s value depends on a sigmoid function of the number of contiguous licenses near a target item of interest.

  • The Multi-Region Value Model (MRVM) (Weiss, Lubin and Seuken, 2017) generates large instances with 98 items and 10 bidders. MRVM captures large settings, such as US and Canadian auctions, by modeling the licenses as being arranged in multiple regions and bands. Bidders’ values are affected by both geography and frequency dimensions of the licenses. Depending on the type and on the number of licenses of interest, bidders are categorized as national, regional  or local. 2828todo: 28In our Management Science paper, we should be a bit more precise when we talk about MRVM. In particular, we are not just using the MRVM model (in the sense that we are not drawing a random world from MRVM), but we are using the Canada world from the MRVM model, with randomly drawn bidders (with paramters based on the Canadian auction). Perhaps it’s useful to clarify this somewhere, either in a footnote or in the appendix, for the purpose of replicability.

In order to implement our machine learning algorithm and mechanism allocation procedures, we need to be be able to solve mixed integer programs (MIPs). In our experiments, we used CPLEX 12.9 (CPLEX, 2019) for this purpose. Experimentally we need to evaluate several different mechanism design choices, and do so with enough data points for statistical signficance. Consequently in our experiments we ran an enormous number of MIPs (approximately ). Accordingly, we adopt a modest timeout for the solver, which we set to 1 minute, and adopt the best solution found so far. We note that in practical use, auctioneers will typically have more time to let the optimizer run (typically at least an hour), which would improve the outcome of our mechanisms; we thus report conservative results with respect to the optimality of the MIP solutions. We conducted our experiments on a computational grid with 20 machines. Each machine has two Intel E5-2680 v2 2.80GHz processors each of which has 10 physical and 20 logical cores.

6.2 Results

In the experiments in this section, we are interested in identifying which kernel to use in the ML algorithm such that the full mechanism will yield the most efficient outcome. In selecting a kernel, we need to optimize the various parameters of the learning algorithm (i.e. ,

, and any kernel hyperparameters). We tune these parameters to maximize the effeciency of the predicted allocation. Because we need the machine learning algorithm to operate within a reasonable comptuational budget, one of the most important parameters is the insensitivity threshold

. This is because, as is standard in kernel-based ML methods, controls the number of support vectors that are likely to be part of the learned model. The size of the winner determination MIP that we solve (see Appendix A) is heavily dependent on the number of support vectors. So determines a tradeoff between the learning error of the ML model, and the runtime of the winner determination optimizer. To investigate this tradeoff, we conducted an experiment on the two expensive kernels, Gaussian and Exponential, which we present in Figure 2, results for the other two domains are provided in Appendix B. To conduct this experiment, we first generate an LSVM domain using SATS. From this domain we then sample truthful bundle-value reports from each bidder. Based on these reports, we train an ML algorithm (with particular parameters) to construct . We then evaluate this and its effectiveness in inferring optimal allocations (in terms of quality and speed) according to four measures of interest which we next describe.

Kernel Efficiency Learning Error WD Solve Time Optimality Gap
100 200 500 100 200 500 100 200 500 100 200 500
Exponential 0 83.0% 83.5% 69.8% 15.68 13.86 11.66 60.00s 60.00s 60.00s 2.40 7.46 109.35
Exponential 64 83.2% 83.7% 83.7% 32.14 30.61 28.74 0.36s 0.40s 3.72s 0.00 0.00 0.00
Exponential 128 83.0% 83.5% 83.7% 48.47 46.01 43.93 0.24s 0.20s 0.20s 0.00 0.00 0.00
Gaussian 0 66.3% 56.3%
17.17 14.70
60.00s 60.00s
6.20 23.46
Gaussian 64 78.1% 81.8% 82.1% 38.32 36.24 34.44 11.79s