An Algorithm for Optimal Winner Determination in Combinatorial Auctions

internalchildlikeInternet and Web Development

Nov 12, 2013 (3 years and 8 months ago)

92 views

An Algorithm for Optimal Winner Determination

in Combinatorial Auctions

Tuomas Sandholm


Computer Science Department, Carnegie Mellon University, 5000 Forbes
Avenue, Pittsburgh, PA 15213, USA
;


E
-
mail address:
sandholm@cs.cmu.edu


This material was first presented as an invited talk at the 1
st

International
Conference on Information and Computation Economics 10/28/1998, and
finally was released in
Artificial Intelligence 135 (2002) 1
-
54

Auction Mechanisms

Sequential Auction

-

Auction items one by one

1.
Easy for sellers (asking
-
side) to determine the winner

2.
Difficult for buyers (bidding
-
side) to win a collection of favorite items.


the
problem is that the market requirement cannot be fulfilled by this kind of
auction mechanisms.


Parallel Auction

-

Auction items at the same time in a period

1.
Easy for sellers to determine the winner

2.
Every buyers who want a collection of favorite items prefers to wait until the
end of the period to see what the going the prices on his favorite items will be
and then to optimize his bids so as to win all of his favorite items.


the
problem is that everybody may use this strategy!


Combinatorial Auction



Buyers bid a combination of items

1.
Very hard (NP) for sellers to determine the winner.


computation problem.

2.
Buyers may flexibly to bid what they want in a fair competition.

Computational Model of Combinatorial Auctions

A collection

of
m

items

Buyers (bidders)



Agent
-
1


Agent
-
2


……


Agent
-
i


……


Agent
-
n

A Seller

M

:: m = |M|

S



b
i
(S) > 0

b
i
(S) = 0 means the bidder i
does not bid on S.

b*

(S) = max
i

bidders

b
i
(S)

b*(S) = 0 means no any buyer bid on S.

P!

max
W

A
(

S

W
b*

(S))

W is a partition of M.

A is the set of exhaustive
partitions on M.

NP!

Objectives:
Maximize
sellers’ revenue

An Example of Exhaustive Partitions on 4 Items

M = {1, 2, 3, 4}

|M| = m = 4


(m
m/2
) <

q=1,2,…,m
Z(m, q) <
O(m
m
)

In other words, q is how many S in
one partition (or level)

max
W

A
(

S

W
b*

(S))

W

S
1
, S
2
, S
3


Solutions to the Winner Determination in
Combinatorial Auctions (NP
-
Complete)

Exhaustive Enumeration


When time or space is infinite, NP=P


Dynamic Programming


M.H. Rothkopf, A. Pekec, R.M. Harstad,
Computationally manageable
combinatorial auctions
, Management Sci. 44 (8) (1998) 1131

1147.


Significantly faster than exhaustive Enumeration


O(3
m
)/

(
2
m
)


Intractable


the key reason is this approach considered every
combination S in the exhaustive partitions even if the corresponding bid
does not happen in practice.

Ideas of The Polynomial Approximation Algorithm

1.
M.H. Rothkopf, A. Pekec, R.M. Harstad,
Computationally manageable
combinatorial auctions
, Management Sci. 44 (8) (1998) 1131

1147.

2.
Only consider “relevant bids” or “relevant partitions”

3.
Restrict the combinations (bids) based on some criteria:


At most 2 items in one bid


O(m
3
)


Use the tree structure to limit the bid forms


O(m
2
)


Bidding based on some ordering of items


Use families of combinations of items in which local winner
determination is very easy

4.
Find the approximate solution, which is close
-
to
-
optimal.

Computing

Speed

Economic

Efficiency

Trade
-
off

The New Optimal Search Algorithm

This paper’s contribution

The
input

(after only the highest bid is kept for every combination of items for which a bid
was received
-

all other bids are deleted) is
a list of bids
:
{B
1
, . . . ,B
n
} = {(B
1S
, B
1b*
), . . . ,
(B
nS
, B
nb*
)}
where B
jS

is the set of items in bid j, and B
jb*

is the price in bid j.

Auction Market

Bidding

1. Preprocessing

2. Construct Bid
-
tree

3. Tree
-
Search for the Solution

IDA* + Branch & Bound Search = SEARCH1 on the Tree

*Organize all the preprocessed bids into a tree:

Features of the Search
-
tree
: The path from the
root to a node (interior or leaf ) corresponds to a
relevant partition. In other words, each relevant
partition W


A’ (relevant) is represented by
exactly one such path.

IDA* + Branch & Bound Search = SEARCH1 on the Tree

*Organize all the preprocessed bids into a tree:

IDA*

At any node, an upper bound on the
total revenue that can be obtained by
including that search node in the

solution is given by f = g + h(F).


The function h(F) gives an upper
bound on how much revenue the
items F that are not yet allocated on
the current search path can
contribute.


“g” is the sum of the prices of the
bids that are on the current search
path.


Branch & Bound Search (BBS)

After the first solution found, the
search switch to BBS for the optimal
solution.

Features of the Search
-
tree
: The path from the
root to a node (interior or leaf ) corresponds to a
relevant partition. In other words, each relevant
partition W


A’ (relevant) is represented by
exactly one such path.


Complexity
: exponential in the number of items
but polynomial in the number of bids.

How to generate such a powerful tree?

Conditions of Tree Construction.
Every relevant partition
W


A’ is represented in the tree by exactly one path from
the root to a node (interior or leaf )
if the children of a node
are those bids that:




include the item with the smallest index among the items
that have not been used on the path yet, and



do not include items that have already been used on the
path

The key is the generation of
children:


Naïve
:


Loop though the list of bids


O(n*m)


Bid
-
tree
:


In the worst
-
case, the
improvement is moderate.


In other cases, it improves
significantly greater. The best
one is O(1) and most of cases
(in the average case) are
O(max(m


log
n, n)

Secondary DFS (SEARCH2) on Bid
-
Tree

*Insert all the preprocessed bids into a bid
-
tree:

Usage of Stopmask


The Stopmask is a vector with one variable
for each item, Stopmask[i], where i

M.


If Stopmask[i] = BLOCKED, SEARCH2 will
never progress left at depth i. This has the
effect that those bids that include item i are
pruned instantly and in place.


If Stopmask[i] = MUST, then SEARCH2
cannot progress right at depth i. This has the
effect that all other bids except those that
include item i are pruned instantly and in
place.


If Stopmask[i] = ANY corresponds to no
pruning based on item i : SEARCH2 may go
left or right at depth i .

i=1

i=2

i=3

M = {1, 2, 3}

IDA*+BBS


In the beginning, Stopmask[1] = MUST and
others Stopmask[i] = ANY.


The first child of any given node in the
search
-
tree is determined by a secondary DFS
from the top of the Bid
-
tree until a leaf (bid)
is reached.

Secondary DFS on Bid
-
Tree (Cont.)

*Insert all the preprocessed bids into a bid
-
tree:

When a bid B is reached, is appended to the
path of the search
-
tree and the algorithm sets
Stopmask[i] = BLOCKED for all i


B.S and

Stopmask[i*] = MUST, where I* is the
minimum index at that time.


When backtracking a bid from the path of the
search
-
tree, all the MUST and BLOCKED
values are changed back to ANY, and the
MUST value is reallocated to the place in the
Stopmask where it was before that bid was
appended to the path.


The next unexplored sibling of any child, j, of
such a node in the search
-
tree is determined
by continuing the secondary
-
DFS. by
backtracking in the Bid
-
tree after the tree
-
search has explored the tree under B.

i=1

i=2

i=3

M = {1, 2, 3}

IDA*+BBS


In the beginning, Stopmask[1] = MUST and
others Stopmask[i] = ANY.


The first child of any given node in the
search
-
tree is determined by a secondary DFS
from the top of the Bid
-
tree until a leaf (bid)
is reached.

Preprocessing for Bid
-
tree Construction

PRE1: Keep only the highest bid for a combination

Inserting a bid into the Bid
-
tree is O(m) because insertion involves following or creating a
path of length m. There are n bids to insert. So, the overall time complexity of PRE1 is O(mn).

PRE2: Remove provably noncompetitive bids

A bid (
prunee
) is non
-
competitive if there is
some disjoint collection of subsets of that bid
such that the sum of the bid prices of the subsets
exceeds or equals the price of the prunee bid.


This picture is to show how to determine a new
bid on (1, 2, 3, 4) being non
-
competitive.


The tree is the search
-
tree which irrelevant bids
are removed.


Search on this tree to make decisions.

$10

$4

$7

Its complexity is similar to the IDA*+BB
if some bid contains all the items, because
it uses the search
-
tree.

PRE3: Decompose the set of bids into connected components

Preprocessing for Bid
-
tree Construction (Cont.)

The bids are divided into sets such that no item is shared by bids from different sets.
PRE4 and the tree
-
search are then done in each set of bids independently, and using
only items included in the bids of the set.

PRE4: Mark noncompetitive tuples of bids

Noncompetitive tuples of disjoint bids are
marked so that they need not be considered on
the same path in SEARCH1.

For example
, the pair of bids $5 for items (1,
3), and $4 for items (2, 4) is non
-
competitive if
there is a bid of $3 for items (1, 2) and a bid of
$7 for items (3, 4)

This is similar to PRE2. The difference is the
prunee is a virtual bid that contains the items
of the bids in the tuple.

The price of the virtual prunee is the sum of
the prices of those bids.

$3

$4

$7

$3

$3

Its complexity is similar to the IDA*+BB
if some bid contains all the items, because
it uses the search
-
tree.

Empirical Evaluation

Complexity



Polynomial in the number of bids


Exponential in the number of items


Four Different Bid Distributions



Random
: For each bid, pick the number of items randomly from 1, 2, . . .,m.
Randomly choose that many items without replacement. Pick the price randomly
from [0, 1].


Weighted random
: As above, but pick the price between 0 and the number of items
in the bid.


Uniform
: Draw the same number of randomly chosen items for each bid. Pick the
prices from [0, 1].


Decay
: Give the bid one random item. Then repeatedly add a new random item
with probability α until an item is not added or the bid includes all m items. Pick
the price between 0 and the number of items in the bid.

Problem instances (random
distribution) tended to be
easy because the bids were
long. So, the search path
was short.


In both the weighted and
the unweighted case, the
curves are sublinear
meaning that execution
time is polynomial in bids.
This is less clear in the
unweighted case.


The bulk of the execution time was spent
preprocessing rather than searching.


On all of the other distributions than
weighted random, the preprocessing time
was a small fraction of the search time.

The uniform distribution
was harder. The bids were
shorter so the search was
deeper.


The second figure shows
the complexity decrease
as the bids get longer, that
is, the search gets
shallower.

In practice, the auctioneer
usually can control the number
of items that are being sold in a
combinatorial auction, but
cannot control the number of
bids that end up being
submitted. Therefore, it is
particularly important that the
winner determination algorithm
scales up well to large numbers
of bids.

On the random and weighted
random distributions, the
algorithm scales very well to
large numbers of bids.

The uniform and decay
distributions were much harder.
However, even on these
distribution, the curves are
sublinear, meaning that
execution time is polynomial in
bids.

On the random and weighted random distributions, the algorithm scales very well to large
numbers of items. The curves are sublinear, meaning that execution time is polynomial in items.

The uniform and decay distributions were harder.
But, the curves are sublinear, meaning that
execution time is polynomial in items.

Conclusion


1.
Exhaustive enumeration and dynamic programming are not
practical.

2.
Limitation on the forms of bidding may sacrifice the
economic efficiency.

3.
The new algorithm is exponential in the number of items
and polynomial in the number of bidding, which fulfill the
market requirement much better by means of limiting on
the number of items.

4.
If the number of items are lot, as long as the sparseness of
bidding is good enough, this algorithm is still practical.



-

THE END
-