L EARNING T RUTHFUL , E FFICIENT , AND W ELFARE M AXIMIZING A UCTION R ULES
A BSTRACT
From social networks to supply chains more and more aspects of how humans ﬁrms and organizations interact is mediated by artiﬁcial learning agents.
As the inﬂuence of machine learning systems grows it is paramount that we study how to imbue our modern institutions with our own values and principles.
Here we consider the problem of allocating goods to buyers who have preferences over them in settings where the seller’s aim is not to maximize their monetary gains, but rather to advance some notion of social welfare (e g. the government trying to award construction licenses for hospitals or schools).
This problem has a long history in economics and solutions take the form of auction rules.
Researchers have proposed reliable auction rules that work in extremely general settings and in the presence of information asymmetry and strategic buyers.
However, these protocols require signiﬁcant payments from participants resulting in low aggregate welfare.
Here we address this shortcoming by casting auction rule design as a statistical learning problem and trade generality for participant welfare effectively and automatically with a novel deep learning network architecture and auction representation.
Our analysis shows that our auction rules outperform state-of-the art approaches in terms of participants welfare, applicability, robustness
I NTRODUCTION
More and more aspects of our lives are mediated by artiﬁcial learning agents; from social networks, to job hunting, and from route planning, to international trade, adaptive systems have become a centerpiece of modern institutions.
As we manage the increased inﬂuence of artiﬁcial intelligence (AI), it is paramount that we are able to imbue our new institutions with our values, and trust them to implement detailed rules and protocols that embody these principles, even in complex, information-asymmetric scenarios with strategic participants.
Here we focus on the problem of designing a protocol for assigning bundles of goods or licenses to strategic buyers who have private valuations over them, and where the seller does not necessarily care about maximizing their proceeds from the sale, but is rather concerned with maximizing some notion of total participant welfare.
This problem has a long history in economics, and solutions take the form of auctions protocols: after bidders report their valuation for the various bundles to the seller, the auction rule prescribes who gets which bundle, and how much each participant owes the seller.
In particular, we highlight the Vickrey-Clarke-Groves (VCG) auction (Clarke, 1971; Vickrey, 1961) which promotes truthful reports from buyers, and works in extremely general settings.
VCG auctions, however, come at the cost of signiﬁcant transfer from buyers to sellers, resulting in low aggregate participant welfare.
This last observation has inspired VCG redistribution schemes, that is, modiﬁed VCG auction rules that recover some participant welfare trading away the general applicability of the original protocol (Guo & Conitzer, 2010).
These redistribution schemes, however, are hard to design, and often come with overly restrictive assumptions on participants preferences or behavior or on the nature of the goods up for sale.
Here we address these limitations by proposing a learning approach to auction rule design.
We show that casting auction design as a learning problem allows us to trade setting generality for participant welfare effectively and automatically, and without need for overly restrictive assumptions (See Tab.for a qualitative comparison).
We start from the often reasonable assumption that bidders’ valuations for the goods up for sale cannot take any value, but rather are sampled from an unknown and ﬁxed probability distribution (e.g. it is very unlikely anyone would pay $500,000 for a burrito).
We introduce a representation of bidders’ preferences and a network architecture that can be used to learn auction rules that a) incentivize truthful reports from participants, b) result in the social-welfare-maximizing allocation of the goods or bundles up for sale, and c) place minimal economic burden on participants (i.e. extract minimal payments).
We show that our approach can learn truthful mechanisms under a wide variety of settings, including various “bidding languges” (Nisan, 2000) (i.e. the set or outcomes that bidders can have preferences over), arbitrary distributions of valuations, and arbitrary numbers of participants.
Furthermore, our detailed analysis shows that the auction rules we learn outperform state-of-the art approaches to auction design in terms or participants welfare and robustness.
Auctions are a pillar of economics and remain the protocol of choice to allocate goods, services, and licenses in many applications world-wide.
Here we show that, under reasonable assumptions, designing auctions that result in desirable allocations, and high participants’ welfare can be cast as an optimization problem, and thus modern learning methods can be brought to bear.
Our work provides an example of how we can imbue desirable values in learning agents and trust them to mediate complex interactions among humans, ﬁrms or other artiﬁcial agents in accordance to those values.
B ACKGROUND AND NOTATION
[Figure]
Channel [Figure] in Channel 4. Channel 6: Assignment of
[Figure]
In this section we provide some background, and introduce speciﬁc notation that will enable us to formally state the problem we tackle.
Auction design : Auctions are protocols to allocate bundles of goods to strategic buyers who have private valuations for them.
The auction rules we consider prescribe that buyers report their preferences to the seller (e.g. telling them how much they value each bundle), at which point the seller uses an allocation rule k , and a payment rule t to determine who gets which bundle, and how much each participant owes.
Thus the auction rules we consider are fully speciﬁed by a choice of allocation rule and payment rule.
More formally, consider a set I of items ordered absolutely (that is, everyone agrees on which is item 1, 2 and so on), and let P ( I ) be the power set of I (i.e. the set of all possible bundles).
An allocation of the items is a function k : N → P ( I ) mapping each participant i to a bundle of items k
( i ) ⊆
I , such that for any i (cid:54) =
j we have k ( i ) ∩ k ( j ) = ∅ (i.e. no item is allocated more than once), we further denote with K the set of all possible allocations.
A payment (or transfer) rule is a function t : N → R that maps each player to an amount they owe the seller; payments can be negative indicating a transfer of money from the seller to the buyer.
Finally, let v i : K → R + be the valuation of participant i for allocation k ; as it is standard in the auction setting, we let v i only depend on the bundle assigned to i (i.e. all allocations where i gets items 1 and 3 have the same valuations: i does not care who among participants j and w gets item 2).
Bidding languages : Auction rules are often bespoke to speciﬁc settings, and the differentiating factor frequently resides in how bundles can be constructed and valued; bidding languages (Nisan, 2000) allow us to formally specify these restrictions, and ensure that allocations remain computable.
In this paper we consider 3 distinct bidding languages: 1) Multi-unit auctions with decreasing marginal utility: 2) Heterogeneous objects with unit demand, and 3) Hierarchical bundles.
In multi-unit auctions with decreasing marginal utilities, we assume that many indistinguishable units of the same product (e.g. oil barrels) are up for sale, and that participants valuation for a bundle only depends on how many units are in the bundle and not which ones, since all units are the same.
Furthermore we assume that bundles with more units cannot be valued less than bundles with fewer units.
In auctions for heterogeneous objects with unit demand, we assume that various distinct products are available for sale (e.g. subscriptions to various cable channels), and that participants have distinct valuation for each individual item available.
Furthermore, we let the valuation of a bundle coincide with that of its most valuable component (e.g. any bundle that includes HBO will be valued as much as HBO since participants can only watch one TV channel at the time).
Finally, in hierarchical bundles, we consider distinct products and allow participants to have valuations over speciﬁc groupings.
Imagine that the items for sale are two pairs of trousers and two blazers, each matching one pair of trousers.
We could let participants express their valuations for each item of clothing individually, for the two matching suits, or for all four items together, assuming no one is interested in purchasing mismatching suits.
More formally, we arrange the items for sale on a binary tree and let participants express preferences for leaf nodes (i.e. individual objects), or any sub-tree.
Efﬁcient allocation : As we stated in the introduction, here we focus on constructing a protocol to allocate goods to strategic buyers that have preferences over them in pursuit of some notion of total welfare.
It is thus a natural choice to allocate bundles “efﬁciently”, that is, so as to maximize the total welfare of participants (before payments): k ∗ = arg max k ∈ K (cid:80) i v i ( k ) .
Strategic behavior : Selecting the welfare maximizing allocation is difﬁcult when the institutions we design do not have access to the true valuation proﬁle of each participant, but rather can only trust what they report.
This asymmetry in information leads to strategic behavior, that is, participants will report whatever preference θ i maximizes their utility u i under the auction rule (note that u i is a function of both allocation and payment).
Formally, let θ − i indicate all reports, truthful or otherwise, from all agents
but i ; then a strategic participant i will report: θ i = arg max θ ∈ Θ
i u i ( k ∗ ( θ − i , θ ) , t ( θ − i , θ )) .
In general θ i (cid:54) = v i .
Truthful mechanisms :
In the presence of strategic participants, and for our choice of allocation function, it is possible to select a payment rule that makes reporting one’s true preferences the dominant strategy.
That is, for any agent i , and for all possible reports, or misreports, from other players θ 1 , . . .
, θ i − 1 , θ i +1 , . . .
, θ n , the best course of action is to tell the truth:
[Equation]
VCG mechanism and Groves payment rule : We restrict our attention to auctions that are both efﬁcient and truthful.
All auction rules with these properties are members of the Groves family, and their payment rule can be written as (Groves, 1973; Green & Laffont, 1979; 1977):
[Equation]
where, h : Θ − i → R is any function that only depends on the reported types of agents other than i , and k ∗ is the efﬁcient allocation.
Within this family, the VCG auction rule satisﬁes two further properties: 1) individual rationality : buyers are never worse off by choosing to participate, i.e. u i ≥ 0 , and 2) weak budget balance : the seller does not need to subsidize the sale (cid:80) i t ( i ) ≥ 0 .
The VCG auction is deﬁned by the following choice of h : h V CG ( θ − i ) =
(cid:80) j (cid:54) =
i v j ( k ∗ ( θ − i )) and resulting payment rule:
[Equation]
Problem statement We aim to design truthful , and efﬁcient auctions that minimize the sum of payments collected by the seller , while keeping the auction individually-rational and weakly budget balanced .
M ETHODS
Setting considered
Guo & Conitzer
Manisha et al.
G-CNN (ours)
R-CNN (ours)
No assumptions on ρ
NO
YES
YES
YES ρ is not known analytically
NO
YES YES YES No restrictions on # [Table]
participants
NO
NO
YES
YES Guarantees no-deﬁcit
YES
NO NO NO Guarantees indiv. rationality
YES
YES
NO
YES
[Table]
YES
NO
YES
YES Unit
[Table]
NO YES YES YES
[Table]
NO
NO
YES
YES
We show how the problem of completing the Groves payment rule can be cast as a learning problem.
We introduce our novel representation of efﬁcient auctions, and a network architecture to learn minimum-payment, truthful auctions.
We also point the reader to (Dütting et al., 2017) for a related approach, and the literature around optimal auction design, which focuses on maximizing the seller’s proceeds, rather than participants welfare (Myerson, 1981;
Riley & Samuelson, 1981).
3. L OSS FUNCTION
As stated in the introduction, we depart from the very general settings of the VCG auction by assuming that participants valuations are not arbitrary, but rather are sampled from a unknown, but ﬁxed, probability distribution ρ .
Our objective is then equivalent to completing the payment rule t ( i ) of a Groves mechanism so that, in expectation over valuation proﬁles sampled from ρ , we minimize the sum total of payments received by the mechanism.
Minimizing payments without any further constraint will result in mechanisms that make t ( i ) arbitrarily negative, and therefore require a subsidy to operate (i.e. they are not budget balanced).
Thus we incorporate a non-deﬁcit constraint.
Similarly, we include an individual rationality constraint for all players.
The resulting “ideal” mechanism design problem we wish to solve is:
[Equation]
where t ( i ) is like in Eq.
As mentioned above, we assume we do not have access to the true distribution ρ , so that we cannot solve this minimization analytically.
As is standard in statistical learning, we assume access to a data-set of L n -player proﬁles D
= { ( v l 1 , . .
. , v ln | l = 1 , . . .
, L } , sampled i.i.d.
from ρ .
We use Lagrange-like multipliers λ b , and λ r to encode the non-deﬁcit, and individual rationality constraints, and minimize the empirical version of our loss:
[Equation]
Concretely, we introduce two distinct ways to learn a Groves payments rule.
The same representation, loss function and network architecture are used in both settings.
Selecting a Groves payment rule : First, we investigate constructing a neural network to implement ˆ h directly and minimize the empirical loss in Eq. 4, given a data-set of valuation proﬁles.
Learning a VCG redistribution mechanism : Second, we learn a VCG redistribution mechanism .
In this case, we use a neural network to implement a redistribution function r ( · ) , and let ˆ h ( · ) =
h VCG ( · ) − r ( · ) 1 .
Note that in this case individual rationality can be guaranteed by simply ensuring that r ( · ) takes non-negative values, since VCG is already individually rational.
3. A UCTION REPRESENTATION
Representing auctions We introduce a novel representation of auctions that supports learning
Groves payment rules with Deep Neural Networks.
Fig.
1 shows an example of our representation and architecture for an auction with three objects and ﬁve participants.
First we note that when computing t ( i ) the function we wish to learn takes as input valuations from “other” players v − i , and has no knowledge of player i ’s proﬁle
(see Eq. 1).
We construct our representation as follows:
ﬁrst, we construct an “allocation oracle” to compute the efﬁcient allocation k ∗ for any set of valuations (this is easy to construct given our choice of bidding languages; see (Nisan, 2000) for details on how to construct such an oracle).
Second, we choose to represent each of the v − i as outcomes of | K | counter-factual auctions, each for the most valuable p bundles with p = 1 , . .
, | K | .
The idea here is to provide information about the relative rank of each bundle valuation.
Precisely, given a data-set of realized valuation proﬁles D , and an allocation oracle, we construct, for each player i a tensor with shape | K | × ( n − 1) × 2 | K | + 1 .
Each | K | × ( n − 1) slice contains matrix V − i ∈ R | K |× ( n − 1) + with non-negative entries ( m, j ) representing the valuation of player j for bundle m (that is v i ( k m ) , where k m allocates m , and nothing else, to j ).
Each successive channel p is constructed by considering a counter-factual auction where the n − 1 players bid for the p most valuable bundles.
In particular, the second channel contains the allocation matrix k ∗ 1 ∈ { 0 , 1 } | K |× ( n − 1) with entries ( m, j ) =
if bidder j is allocated bundle m in this auction, and zero otherwise.
The third channel represents the amount of utility realized by each player for this allocation before payments (i.e. the element-wise product between the ﬁrst and second channels).
Similarly, the fourth channel contains k ∗ 2 : the allocation for two bundles, and the ﬁfth channel contains the element-wise product between channels 1 and 4, and so on until all bundles are considered.
We alter this representation slightly to in multi-unit auctions with decreasing marginal utilities.
In this case we let V − i be a matrix with shape | B |× ( n − 1) , with B the set of available items, and containing, for each player, the marginal utility of adding one item to their bundle.
A network architecture to learn Groves payment rules Given our auction representation, we propose an architecture to learn a Groves payment rule that satisﬁes the following: a) anonymity : the same exact function is applied to each player, b) robustness to ordering: t ( i ) does not change if players j and w swap valuations.
For each player i , we construct the input tensor of size | K |× ( n − 1) ×
(2 | K | +1) described above and pass it through a 2 -layer CNN.
The ﬁrst layer uses 64 ﬁlters of spatial size 1 × 1 so as to construct an embedding of each individual bid (how soon each bundle is allocated, and how much utility it realizes can be readily extracted from a single “column” in our representation).
The second CNN layer hasﬁlters of size | K | × 1 .
The CNN’s output thus has size 1 × ( n − 1) × 64 , and contains an embedding of each of the n − 1 players’ preferences.
We follow our CNN with a 2-Layer, 64 hidden and output units MLP, which we apply independently to each of the ( n − 1) player preference embeddings to produce a new embedding for each player.
We then sum-pool over the n − 1 players (which guarantees the desired robustness properties), and apply a linear decoder (with ReLU rectiﬁcation) to output a single value for either ˆ h directly, or for a redistribution function r .
It is worth noting that this architecture is a DeepSets network applied to a graph of n − 1 nodes with a single global output, where node functions are our CNN+MLP and the aggregator function is a sum (Zaheer et al., 2017;
Battaglia et al., 2018).
3. E XPERIMENTAL PROCEDURE AND BASELINES
Baselines We consider four baselines.
1) VCG auctions , the most commonly used Groves mechanism: a truthful, efﬁcient, weakly budget balanced and individually rational auction.
2) Guo & Conitzer (2010) a provably optimal-in-expectation linear VCG redistribution mechanism, which requires n < | K | , analytical knowledge of ρ , and only handles multi-unit auctions.
3) Manisha et al.
a
VCG redistribution learned using a MLP architecture that requires n < | K | , and only works with unit-demand valuations.
4) MLP based architecture lastly, we compare to a 2-layer, 128-hidden-unit
MLP that operates on a ﬂattened version of the same data as our method to empirically support our choice of representation and architecture.
Experimental procedure For each combination of number of participants, valuation distribution and bidding language considered, we construct sample auctions (i.e. valuation proﬁles for all participants, expressed in the appropriate language) and collect training and validation data-sets containing 100 , 000 and 2 , 000 auctions respectively.
For each auction, we construct the representation described in Sec. 3.2, and train the auction design network above using Adam SGD (Kingma &
Ba, 2015) with a learning rate of 10 − 5 , mini-batches of size 256 , and for 250 , 000 iterations.
In all experiments we set λ b = λ r = 100 (see Eq. 4).
After training, we use our held-out test set to report performance.
The number of objects for sale were as follows: with non-decreasing marginal utilities: 15 objects, with heterogeneous objects and unit-demand: 8 objects, and with hierarchical bundles:component objects (resulting in 15 bundles).
R ESULTS
Qualitative comparison with alternative methods We start with a qualitative comparison with two existing alternative methods to automatically construct VCG redistribution protocols, and highlight how our method can be applied in more general settings in Tab. 1.
A quantitative comparison with these two methods (in the settings in which they can be applied) shows how our methods also leads to better performance in practice.
Importantly, while our method does not guarantee we will ﬁnd auctions that are weakly budget balanced and individually rational, our quantitative results show that, in practice, we ﬁnd zero, or next-to-zero violations of these constraints, and in particular the individual rationality constraint is never violated (this is expected since we are minimizing payments, thus making participation more appealing).
Quantitative results We illustrate quantitative results on synthetic auction data-sets in Fig.
Fig.
2a shows the performance of auctions learned using our two methods G-CNN (where we learn a
Groves payment rule directly), and R-CNN (where we learn a redistribution mechanism).
It is clear how the auctions we learn result in high redistributions with minimal budget balance violation (none for R-CNN).
For this experiment, valuations were sampled from a Gaussian with mean and standard deviations sampled from two independent Gaussian distrbutions ρ = N ( N (10 . 0 , 1 . 0) , N (2 . 0 , 0 . 5)) .
Furthermore, this experiment showcases the high applicability of our method (the only method to support all three bidding languages), and our architecture’s ability to interpolate to unseen number of
[Figure] [Figure]
The goal of our design is to construct payment rules that concentrate the redistribution as close as possible to 100% without ever exceeding it: concentrations around high redistribution scores that participant achieve high aggregate welfare (i e. low net payments), while redistributions exceeding 100% indicate that the auctioneer incurred a deﬁcit (i.e. the weak budget balance constrained is violated).
In both ﬁgures R-CNN refers to learning a VCG redistribution scheme with our representation and architecture, whereas G-CNN refers to the case where we learn a payment rule directly (see Sec. 2). Fig.
participants: training was performed using auctions with either 9 or 11 participants, while testing used auctions with 10 participants; no other method supports this transfer learning.
Fig.
2b shows a comparison between our method, an MLP network that operates on the same data, so as to validate our choice of data representation and network architecture, and the work from Manisha et al.
The distributions of valuations we used for this experiment where a
Gaussian with mean and standard deviations sampled from two independent Gaussian distributions ρ = N ( N (10 . 0 , 1 . 0) , N (2 . 0 , 0 . 5)) , a Gaussian with ﬁxed mean and standard deviation: ρ =
N (10 . 0 , 2 . 0) , and the uniform distribution: ρ = U (0 . 0 , 1 . 0) .
Only unit demand auctions with n =participants were used since the work from Manisha et al.
requires n < | K | and does not support other bidding languages.
We end this section with a quantitative comparison with the provably optimal in expectation redistribution scheme of Guo & Conitzer (2010), in the only setting where it is applicable: multi-unit auctions with decreasing marginal utility with valuation sampled from the uniform distribution, and n < | K | .
Speciﬁcally we consider two settings, and report performance as fractions of the aggregate
VCG payments returned (we report redistribution mean and standard deviation exclusively since the baseline results are pulled directly from the original paper).
With n = 3 R-CNN redistributes 80 ± 1% of VCG payments with a deﬁcit of 0 ± 0% , G-CNN redistributes 87 ± 1% of VCG payments with a deﬁcit of 0 ± 1% , while the redistribiton scheme of Guo & Conitzer (2010) redistributes 76% of VCG payments, and guarantees no deﬁcit.
With n = 7 R-CNN redistributes 84 ± 6 of VCG payments with a deﬁcit of 0 ± 0% , G-CNN redistributes 95 ± 0% of VCG payments with a deﬁcit of 0 ± 1% , while the redistribiton scheme of Guo & Conitzer (2010) redistributes 94% of VCG payments and guarantees no deﬁcit (mean and std.
dev.
over 2000 held out synthetic auctions for
G-CNN and R-CNN).
Our experiments show that auctions learned using our statistical learning formulation, data representation and network architecture result in a signiﬁcantly smaller economic burden on the participants than alternative designs, and crucially, that we are able to learn auction rules with a better trade-off between participant welfare and budget balance violations.
Furthermore, our experiments showcase the wide applicability and robustness of our method with respect to choice of bidding languages, number of participants, distribution of valuations, and interpolation to unseen scenarios.
D ISCUSSION
We introduced a novel way to represent auctions, and proposed a neural architecture, to learn truthful and efﬁcient auctions with minimal economic burden on the participants.
Our methods can be applied on a wide variety of settings including arbitrary distributions, complex bidding languages and variable number of participants.
Our empirical analysis shows how the resulting auctions yields high participants’ welfare and almost never require a subsidy.
Moreover, restricting our auction designs to the Groves family provides a template for constructing adaptive systems that remain ﬁrmly planted in the theoretical foundations of economics and mechanism design.
Auction design is a pillar of economics and social sciences and the domain of choice to study how a institution can mediate the interactions of strategic participants in pursuit of group-level aspirations (e.g. maximize aggregate welfare).
Nonetheless, very few attempts to apply machine learning ideas to this setting have been made.
Here we have shown that, under reasonable assumptions, auction design can be turned into a statistical learning problem and modern methods can be brought to bear.
The recent renaissance of Artiﬁcial Intelligence points to a future where institutions are largely built around adaptive systems, and where we must entrust learning agents with the automatic translation of high-level directives into low-level incentive structures and interaction rules.