Effectiveness of preference elicitation in combinatorial auctions

1
Effectiveness of preference elicitation in
combinatorial auctions

• Benoît Hudson Tuomas Sandholm
• July 16, 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
Communication Problem

• Auctioneer must know valuation functions of each
  agent.
• Utility 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 Nisan Segal01

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

8
Elicitation (cont.)

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

9
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.)

10
Constraint Network
111
1 per agent
110
101
011
100
010
001
000
11
Constraint Network
0,?
111
Upper bound
0,?
0,?
0,?
110
101
011
Lower bound
0,?
0,?
0,?
100
010
001
0
000
12
Constraint Propagation
0,?
111
vi(110)5
0,?
0,?
5
110
101
011
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
5,?
111
vi(110)5
0,?
0,?
5
110
101
011
0,5
0,5
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
0,?
0,?
5
110
101
011
0,5
0,5
0,?
100
010
001
0
000
17
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.

18
Are we done yet?

• Need to stop when enough information has been
  gathered.
• Store list of possible allocations (candidates)
  C
• After each phase, eliminate allocations for which
  we can prove v(c) ? v(c)
• In particular, v(c) ? OPT
• Stop when C 1, declare the winning allocation.

19
What to ask?

• The hardest question.
• We spend the rest of the talk looking at various
  approaches.
• Value queries.
• Order queries.
• Bound queries.
• Some theoretical, mostly experimental results.

20
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 10 runs.
• Each plot takes 20min 6hr to run (depending on
  query policy) could be made much faster.

21
What to ask?

• Easy answer value queries
• ask bidder i its value for bundle b
• How to choose b, i ?
• First, try randomly.

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?
• Is it tight? Run experiments.

23
Experiments random

• Not much better than theoretical bound

queries
queries
2 agents
4 items
80
1000
60
Full revelation
100
Queries
40
10
20
1
2
3
4
5
6
9
2
3
4
5
6
7
8
10
agents
items
24
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.

25
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.

26
Allocatable-only results

• Much better
• Factor of about 0.5 k savings.

queries
queries
80
1000
60
Full revelation
100
40
Queries
10
20
1
2
3
4
5
6
9
2
3
4
5
6
7
8
10
agents
items
27
A better value-based policy

• Adapted from Smith,Simmons,Sandholm02
• Find candidates 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)

28
A better value-based policy

• This new policy does demonstrably better (a
  factor of 2) than random-allocatable.

queries
queries
80
1000
Full revelation
60
Random
100
40
Highest-UB(c)
10
20
1
2
3
4
5
6
4
6
8
2
10
12
agents
items
29
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 ?

30
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

31
ValueOrder results

• Total cost slightly reduced vs. allocatable-only
• Cost reduction depends on relative costs

queries
queries
80
1000
Full revelation
60
Total cost
100
Value cost
40
10
20
Order cost
1
2
3
4
5
6
9
2
3
4
5
6
7
8
10
agents
items
32
Rank queries

• Another query type
• Have each agent rank their preferences (total
  ordering over the bundles)
• This forms a lattice
• Go down the lattice in best-first order

33
Rank lattice

• Performance not as good as value-based why?
• nodes in rank lattice is 2nk
• feasible nodes is only nk

Also agent that is shut outmust reveal its
entire valuation.
queries
queries
80
1000
Full revelation
60
100
40
Queries
10
20
1
2
3
4
5
6
4
6
8
2
10
12
agents
items
34
Rank lattice

• Can we do better?
• Conen,Sandholm02 seems to imply we cannot.
• Also, asking for the top 10 may be reasonable,
  but asking for the 1374th-ranked bundle is odd.
• Requires agents to know a total ordering over
  bundles

35
Bound-approximation queries
Check for Parkes reference

• 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, UB or LB ?

36
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

37
Bound-approx query results

• This policy does fairly well.
• Future work try other related policies.

queries
queries
160
1000
Full revelation
120
100
Query cost
80
10
40
1
2
3
4
5
6
9
2
3
4
5
6
7
8
10
agents
items
38
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 ?.

39
Adding order queries

• Can easily integrate bound queries, order
  queries, as before
• Computationally more expensive (cut-off at 9
  items)

queries
queries
160
1000
Full revelation
120
Total cost
100
80
Order cost
10
Value cost
40
1
2
3
4
5
6
9
2
3
4
5
6
7
8
10
agents
items
40
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.

41
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.

42
Vickrey payments

• We solved winner determination.
• In a Vickrey auction, need to compute payments as
  well.
• Trivial worst-case bound factor of (n1) more
  queries.
• In practice, very little extra is needed.
• No more at two agents.
• About 20 more with 3-6 agents.

43
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
• Rank-based elicitation schemes do not seem to
  scale in agents other schemes do.

44
Future work

• Theoretical results on these policies.
• More policies, query types.
• Better data structures algorithms
• Current run-time exp in items, poly in agents
• Current space exp in items, linear in agents
• Reverse auctions, exchanges.
• Link with bidding languages work.