Preference elicitation in combinatorial auctions

1
Preference elicitation in combinatorial auctions

• Benoît Hudson Tuomas Sandholm
• November 20, 2002

2
Combinatorial Auctions

• We are selling k items to n agents.
• In series economically inefficient.
• Use a Generalized Vickrey Auction
• Economically efficient (under reasonable
  assumptions)

3
Generalized Vickrey Auction

• Closed bids
• Find allocation of items to agents that maximizes
  sum of bids
• Truthful ? this maximizes social welfare
• Selling price negative externality
• a others social welfare in auction run with i
• b others social welfare in auction run without
  i
• Payment b-a (always positive)

4
Combinatorial Auctions

• We are selling k items to n agents.
• In series economically inefficient.
• Use a Generalized Vickrey Auction
• Economically efficient (under reasonable
  assumptions)
• NP-hard, inapproximable
• Exponential communication, inapproximable

5
Bidding Problem

• Bidders must know valuation functions .
• Valuation function defined at 2items points.
• Also, evaluation at each point may be very
  expensive (i.e. solve a TSP).
• No short representation of valuation function in
  general case.

6
Communication Problem (cont.)

• Agents need to decide what to bid on
• Waste time on counter-speculation
• Waste time making losing bids
• Fail to make the optimal bid
• Suffer reduced economic efficiency

7
Elicitation

• Agents have insufficient information.
• Auctioneer can integrate information between
  agents
• Have auctioneer recommend what agents should bid
  on Conen Sandholm 01
• i.e. auctioneer elicits information
• still has exponential communicationNisan, Segal
  2002

8
Outline

• A framework.
• Value-based policies.
• Oracles.
• An optimal but intractable algorithm.
• Other query types.
• Other musings.

9
A framework

• Goal minimize elicitation
• Regardless of auctioneer's computational cost
• (Future work tradeoff bidder/auctioneer
  computation)
• Approach
• At each phase
• Decide what to ask.
• Ask it, store the answer.
• See whether we can clear the auction yet.

10
Storing the answer

• Interval constraint networks, 1 per agent
• Nodes store upper/lower bounds on value of
  bundle
• Edge (b,b) means vi(b) ? vi(b)
• At start create all nodes, add edges for free
  disposal.
• Could make other assumptions (like
  sub-modularity, etc.)

11
Constraint Network
111
1 per agent
110
101
011
100
010
001
000
12
Constraint Network
0,?
111
Upper bound
0,?
0,?
0,?
110
101
011
Lower bound
0,?
0,?
0,?
100
010
001
0
000
13
Constraint Propagation
0,?
111
vi(110)5
0,?
0,?
5
110
101
011
0,?
0,?
0,?
100
010
001
0
000
14
Constraint Propagation
0,?
111
vi(110)5
0,?
0,?
5
110
101
011
0,?
0,?
0,?
100
010
001
0
000
15
Constraint Propagation
5,?
111
vi(110)5
0,?
0,?
5
110
101
011
0,5
0,5
0,?
100
010
001
0
000
16
Constraint Propagation
5,?
111
vi(110)5
0,?
0,?
5
110
101
011
0,5
0,5
0,?
100
010
001
0
000
17
Constraint Propagation
5,?
111
0,?
0,?
5
110
101
011
0,5
0,5
0,?
100
010
001
0
000
18
Constraint Propagation

• Davis87 shows propagation is
• Complete for assimilation (values for UB, LB are
  as tight as they can be made).
• Incomplete for inference (cannot always use
  values to infer vi(b) ? vi(b)).
• Need to use both values and network topology
  during inference.
• vi(b) ? vi(b) if LBi(b) ? UBi(b) or edge
  (b,b')

19
Are we done yet?

• Need to stop when enough information has been
  gathered.
• Store list of possible allocations (candidates)
  C
• After each phase, prune C remove allocations for
  which we can prove v(c) ? v(c)
• In particular, v(c) ? OPT
• Stop when C 1, declare the winning
  allocation.
• C starts with all allocations nk of them.
• each item can be allocated to any of the n agents

20
Outline

• A framework.
• Value-based policies.
• Oracles.
• An optimal but intractable algorithm.
• Other query types.
• Other musings.

21
What to ask?

• Easy answer value queries
• ask bidder i its value for bundle b
• How to choose b, i ?
• Easiest policy ask a random query
• build set of all n (2k-1) queries
• k items, 2k bundles, empty bundle has value 0
• pick randomly from the set

22
Random elicitation

• Theoretically if the best policy makes q
  queries and there are Q possible queries to be
  made, we make
• from we have q red balls, and the remaining
  balls are blue how many balls do we draw before
  removing all q red balls? (pf Maverick)
• Is it tight? Run experiments.

23
Experiments

• Simulations
• Draw agents valuation functions from a random
  distribution.
• Current distribution (roughly) uniform over all
  monotone valuations.
• Each point on plots is average of 50 runs.

24
Experiments random
25
Allocatability

• Bundle-agent pair (b,i) is allocatable if some
  candidate in C allocates bundle b to agent i
• How to pick (b,i)?
• Pick a random allocatable one
• From now on, I only look at allocatables.

26
Allocatable-only policy

• Asking only allocatable bundles means we throw
  out some possible queries.
• These ignored queries are either
• Not useful to ask, OR
• Useful, but we would have had low probability of
  asking it, so no big difference in expectation
  (factor of ?2 less elicitation).
• Proof to finish, we need to ask either x
  allocatable queries, or 1 non-allocatable.
  Expect to ask x/2 queries.

27
Allocatable-only results
n4, k5 50 (was 85)
n2 k9 20 (was 78)
28
A better value-based policy

• Adapted from Smith,Simmons,Sandholm02
• Find candidates Cmax with highest UB(c)
• Among those, pick (b,i) that maximizes the number
  of other b whose value is reduced
• roughly speaking, the largest bundle
• (b',i) in Cmax such that UBi(b') gt LBi(b) and
  network has a link from b to b'

29
A better value-based policy
n4, k5 45 (was 50)
n2 k9 10 (was 20)
30
Elicitor runtime

• So far, we've ignored elicitor runtime
• Main cost pruning
• O(C2) per query
• Idea 1 dont want to store candidates
• Idea 2 we only need the best allocation
• Idea 3 I have an underused CPLEX license
• Solution solve a large number of IPs

31
Avoiding candidates

• Find value of Cmax candidates (solve an IP)
• For each (b,i) see how much value we can get
  using it (force xi(b)1, solve the IP)
• If equal value, (b,i) is in Cmax
• nk candidates, n2k possible (b,i)
• n2k ltlt nk when n gt 2

32
More speedups

• We solve n2k integer programs.
• Avoid solving so many by caching old answer for
  each (b,i)
• Upper bounds always decrease, so old answer ? new
  answer
• If old answer lt value of Cmax don't recompute
  (new answer will also be less)

33
Outline

• A framework.
• Value-based policies.
• Oracles.
• An optimal but intractable algorithm.
• Other query types.
• Other musings.

34
Non-deterministic elicitation

• Assume auctioneer has an oracle that says which
  allocation is optimal. How to verify?
• To prove optimality, need to
• Prove sufficiently tight LB on optimal
• Prove sufficiently tight UB on all others
• Question how much worse is deterministic than
  non-deterministic?
• Reasonable performance measure.

35
Implementing the oracle

• Find the shortest ceritificate using ID
• try all query sets of length f
• if any is a certificate, report it
• else f f1 and try again
• Shortcut 1 I know (K,i) is always revealed
• Shortcut 2 Impose lexicographic order on queries
  (search space is a tree, not a graph)

36
IDA search

• Heuristic
• to prove opt is the optimal candidate, need to
  prune all other candidates
• lower bound on queries is max over all
  candidates c of min queries to prune c
• if any candidate is unprunable, h ?
• Very weak h ? 2n and does not vary with kBut
  queries is exponential in k!!

37
Yet Another Graph
n3 k4 33 (was 50)
n5 k3 41 (was 46)
38
Outline

• A framework.
• Value-based policies.
• Oracles.
• An optimal but intractable algorithm.
• Other query types.
• Other musings.

39
Optimality realistically

• Omniscience is not reasonable.
• Use similar ideas in a realistic setting at
  every step
• try all query sets of length f
• see what answers might be
• if any constitutes a certificate, ask a query
  from that set
• else f f1 and try again
• (This is a game-tree search!)

40
Optimality "certificate" ?

• Assuming adversarial setting, the adversary can
  always make us ask all queries
• Assuming more natural setting (valuations drawn
  from distribution)
• probability of each outcome difficult to find
• Totally intractable in either case

41
Optimality what now?

• Obvious idea partial lookahead
• fix f a priori
• for each set of f queries, compute expected
  utility of asking those queries
• ?x p(x) u(x) where x is a possible outcome
• ask query that maximizes that sum, but
• p(x) hard to compute
• u(x) ??? number of candidates pruned? amount
  bounds change? number of upper bounds reduced in
  high-value candidates?

42
Outline

• A framework.
• Value-based policies.
• Oracles.
• An optimal but intractable algorithm.
• Other query types.
• Other musings.

43
Order queries

• Intuition it may be much easier to answer a is
  more valuable than b than to answer a is worth
  351.92, b is worth 358.13
• Order query agent i, is bundle b worth more to
  you than bundle b ?
• Order queries insufficient
• How to interleave order, value queries?
• How to choose i, b, b ?

44
ValueOrder

• Interleave
• 1 value query (using allocatable-only policy)
• 1 order query (pick arbitrary allocatable i, b,
  b)
• To evaluate 1 for value, 0.1 for order
• Useful when order queries much cheaper

45
ValueOrder results
About 10 fewer value queries total cost equal
to value only policy. Need (1) better order
query choice (2) better interleaving
46
Bound-approximation queries

• Larson,Sandholm01 model bounded-rational
  agents as having on-line algorithms
• Get better bounds UBi(b) and LBi(b) with more
  time spent deliberating
• Query agent i, please spend t time units
  tightening the (upper or lower) bound on b
• How to choose i, b, t, U or L ?

47
Bound-approx query policy

• For simplicity, fix t 0.2 units (1 unit gives
  exact)
• Can choose randomly.
• More complicated policy does slightly better
• Choose query that will change the bounds on
  allocatable bundles the most
• Dont know exactly how much bounds will change
• Assume all legal answers equiprobable, sample to
  get expectation

48
Bound-approx query results
Note "ratio" not really comparable here and in
value policies. Need (1) High-value? (2) More
realistic cost accounting.
49
Bound-approximation a note

• We calculated the change but what is change from
  ? ?
• Can prove that we always need an upper bound on
  value of grand bundle.
• Proof obvious if nobody gets grand bundle,
  (usual case under this distribution) less
  obvious otherwise.
• Policy actually is ask everyone for a UB on the
  grand bundle.
• After that, we neednt worry about ?.

50
Outline

• A framework.
• Value-based policies.
• Oracles.
• An optimal but intractable algorithm.
• Other query types.
• Other musings.

51
Bidding Languages

• Bidding languages can offer a more terse
  representation of the valuation function.
• For simplicity, our work assumes an XOR bidding
  language value query gt ask agent to reveal one
  term of the XOR
• Could be extended to other bidding languages
  future work.

52
Vickrey payments

• We solved winner determination.
• In a Vickrey auction, need to compute payments as
  well.
• In practice, very little extra is needed.
• No more at two agents (theoretical bound 4 extra
  queries in practice, 0 extra queries)
• About 20 more with 3-5 agents.

53
Reverse auctions

• Forward auction auctioneer selling items to
  agents.
• each item sold at most once
• Reverse auction auctioneer buying items from
  agents.
• each item bought at least once
• Reverse is easier to approximate (still NP-hard)

54
Reverse auction elicitation
Analogue to high-value policy Find low-LB
candidates, ask (b,i) that will affect the most
lower bounds.
55
Reverse auction elicitation

• Interesting details
• runs somewhat faster (unsurprising)
• elicitation falls with more agents, rather than
  rising (surprising, I think)
• 3 agents much less elicitation than forward

56
Conclusion

• Elicitation can reduce amount of valuation
  function that needs to be revealed
• Save on communication
• Save on bidder-side computation
• Reduce revelation of private information
• Scale in items and maintain benefit in agents

57
Future work

• Theoretical results on these policies.
• Better policies, query types.
• Making a near-optimal policy
• Better data structures algorithms
• Current run-time exp in items, poly in agents
• Current space exp in items, linear in agents
• for best policy others are poly in agents
• Link with demand queries
• Auctioneer proposes prices, sees what agents
  would buy.

58
Last slide!

• And for what I want to know now
• how hard is finding the shortest certificate
  ("implementing the oracle") NP-complete?
• there must be a better heuristic
• why does elicitation grow with agents in
  forward, shrink in agents with reverse auctions?