Auctions

1. Auctions Automated Negotiation

2. Auction Protocols • English auctions • First price sealed-bid auctions • Second best price sealed-bid auctions (Vickery auctions) • Dutch auctions

4. The Contract Net R. G. Smith and R. Davis

5. DPS System Characteristicsand Consequences • Communication is slower than computation— loose coupling— efficient protocol— modular problems— problems with large grain size

6. More DPS System Characteristicsand Consequences • Any unique node is a potential bottleneck— distribute data— distribute control— organized behavior is hard to guarantee (since no one node has complete picture)

7. The Contract Net • An approach to distributed problem solving, focusing on task distribution • Task distribution viewed as a kind of contract negotiation • “Protocol” specifies content of communication, not just form • Two-way transfer of information is natural extension of transfer of control mechanisms

8. Four Phases to Solution,as Seen in Contract Net 1. Problem Decomposition 2. Sub-problem distribution 3. Sub-problem solution 4. Answer synthesis The contract net protocol deals with phase 2.

9. Contract Net • The collection of nodes is the “contract net” • Each node on the network can, at different times or for different tasks, be a manager or a contractor • When a node gets a composite task (or for any reason can’t solve its present task), it breaks it into subtasks (if possible) and announces them (acting as a manager), receives bids from potential contractors, then awards the job (example domain: network resource management, printers, …)

10. Node Issues Task Announcement Task Announcement Manager

11. Idle Node Listening toTask Announcements Manager Potential Contractor Manager Manager

12. Node Submitting a Bid Bid Manager Potential Contractor

13. Manager listening to bids Bids Potential Contractor Manager Potential Contractor

14. Manager Making an Award Award Manager Contractor

15. Contract Established Contract Manager Contractor

16. Domain-Specific Evaluation • Task announcement message prompts potential contractors to use domain specific task evaluation procedures; there is deliberation going on, not just selection — perhaps no tasks are suitable at present • Manager considers submitted bids using domain specific bid evaluation procedure

17. Types of Messages • Task announcement • Bid • Award • Interim report (on progress) • Final report (including result description) • Termination message (if manager wants to terminate contract)

18. Efficiency Modifications • Focused addressing — when general broadcast isn’t required • Directed contracts — when manager already knows which node is appropriate • Request-response mechanism — for simple transfer of information without overhead of contracting • Node-available message — reverses initiative of negotiation process

19. Message Format • Task Announcement Slots:— Eligibility specification— Task abstraction— Bid specification— Expiration time

20. Task Announcement Example(common internode language) To: * From: 25 Type: Task Announcement Contract: 43–6 Eligibility Specification: Must-Have FFTBOX Task Abstraction: Task Type Fourier Transform Number-Points 1024 Node Name 25 Position LAT 64N LONG 10W Bid Specification: Completion-Time Expiration Time: 29 1645Z NOV 1980

21. The existence of a common internode language allows new nodes to be added to the system modularly, without the need for explicit linking to others in the network (e.g., as needed in standard procedure calling).

22. Applications of the contract Net • Sensing • Task Allocation (Malone) • Delivery companies (Sandholm) • Market-oriented programming (Wellman)

23. Bidding Mechanisms for Data Allocation A user sends its query directly to the server where the needed document is stored.

24. Environment Description a client a document a query distance serverj serveri area i area j

25. Utility Function • Each server is concerned only whether a dataset is stored locally or remotely, but is indifferent with respect to different remote location of the dataset.

26. The Trading Mechanism • Bidding sessions are carried on during predefined time periods. • In each bidding session, the location of the new datasets is determined and the location of each old dataset can be changed. • Until a decision is reached, the new datasets are stored in a temporary buffer.

27. The Trading Mechanism - cont. • Each dataset has an initial owner (called contractor(ds)), according to the static allocation. • For an old dataset - the server which stores it. • For a new dataset - the server with the nearest topics (defined according to the topics of the datasets stored by this server).

28. The Bidding Steps • Each server broadcasts an announcement for each new dataset it owns, and also for some of its old local datasets. • For each such announcement, each server sends the price it is willing to pay in order to store the dataset locally. • The winner of each dataset is determined by its contractor. It broadcasts a message, including: the winner, the price it has to pay, and the server which bids this price.

29. Cost of Reallocating Old Datasets • move_cost(ds,bidder):the cost for contractor(ds) for moving ds from its current location to bidder. (for new datasets, move_cost=0) • obtain_cost(ds,bidder):the cost for bidder for moving ds from its current location to bidder.

30. Protocol Details • winner(ds) denotes the winner of dataset ds. • winner(ds)= arg max bidder move(ds)=trueprice_suggested(bidder,ds) -move_cost(ds,bidder) none otherwise

31. Protocol Details - cont. • price(ds) denotes the price paid by the winner for dataset ds. • price(ds)= second_max bidder־SERVERS { price_suggested(s,ds) -move_cost(ds,bidder) }+ move_cost(ds,winner).

32. Bidding Strategies • Attribute:move(ds)=true ifsecond_maxbidder־SERVERS {price_suggested(bidder,ds) - move_cost(ds,bidder)} ³Ucontractor(ds)(ds,contractor(ds)).

33. Bidding Strategies - cont. • LemmaIf the winner server had bid its true value of storing the dataset locally, then it will have a nonnegative utility from obtaining it. • LemmaEach server will bid its utility from obtaining the dataset:price_suggested(bidder,ds)=Ubidder(ds,bidder) - obtain_cost(ds,bidder).

34. Bidding Strategies - cont. • TheoremIf announcing and bidding are free, then the allocation reached by the bidding protocol leads to better or equal utility for each server than does the static policy.The utility function is evaluated according to the expected profits of the server from the allocation.

35. Usage Estimation • Each server knows only the usage of datasets stored locally. • For new datasets and remote datasets, the server has no information about past usage. • It estimates the future usage of new and remote datasets, using the past usage of local datasets, which contain similar topics.

36. Queries Structure • We assume that a query sent to a server contains a list of required documents. • This is the situation if the search mechanism to find the required documents is installed locally by the client. • In this situation, the server has to learn from the queries about its local documents, to the expected usage of other documents, in order to decide whether it needs them or not.

37. Usage Prediction • We assume that a dataset contains several keywords (k1..kn). • For each local dataset ds, and each server d, the server saves the past usage of ds by d, in the last period • Then, it has to predict the future usage of ds by d. It assumes the same behavior than in the past.

38. Usage Prediction - cont. • It is assumed that the users are interested in keywords, so the usage of a dataset is a function of the keywords it contains. • The simplest model is: when a dataset usage is the sum of the the usage of each of its keywords. However, the relationship between the keywords and the dataset may be different.

39. Usage Prediction - cont. • The server has to learn about usage of datasets not stored locally: • We suggest that it will build a Neural Network for learning the usage template of each area.

40. What is Neural Network • A neural network is composed of a number of nodes, or units, connected by links. • Each link has numeric weight associated with it. • The weight are modified so as to try to bring the network’s input/output behavior more into line with that of the environment providing the input.

41. Neural Network - Cont. Output unit Output layer Hidden layer Input layer Input unit

42. Structure of the Neural Network • For each area d, we build a neural network. • Each dataset stored by the server in area d, is one example for the neural network of d. • The inputs of the examples contain, for each possible keyword, whether it exist in this dataset, or not.

43. Structure of the Neural Network - cont. • The output unit of the Neural Network for area d, is its past usage of this dataset. • In order to find the expected usage of another dataset, ds2, by d, we provide the network with the keywords of ds2. • The output of the network is its predicted usage of ds2 by area d.

44. Structure of the NN Output unit: the usage of the dataset by a certain area. Hidden layer For a certain dataset, for each keyword k there is an input unit: 1 if the dataset contains k. 0 otherwise.

45. Experimental Evaluation - Results Measurement • vcosts(alloc) - the variable cost of an allocation, which consists of the transmission costs due to the flow of queries. • vcost_ratio: the ratio of the variable costs when using the bidding mechanism and the variable costs of the static allocation.

46. Experimental Evaluation • Complete information concerning previous queries (still uncertainty): • The bidding mechanism reaches results near to that of the optimal allocation (reached by a central decision maker). • The bidding mechanism yields a lower standard deviation of the servers utilities than the optimal allocation. • Incomplete information: • The results of the bidding mechanism are better than those of static allocation.

47. Influence of ParametersComplete Information, no movements of old datasets • As the standard deviation of the distances increases, vcost_ratio decreases.

48. Influence of Parameters - cont. • When increasing the number of servers and the number datasets, vcost_ratio is not influenced. • query_price, answer_cost, storage_cost, dataset_size and retrieve_ cost donot influence vcost_ratio. • usage, std. usage, distance donot influence vcost_ratio.

49. Influence of Learning on the System • As epsilon decreases, vcost ratio increases: the system behaves better.

50. Conclusion • We have considered the data allocation problem in a distributed environment. • We have presented the utility function of the servers, which expresses their preferences over the data allocation. • We have proposed using a bidding protocol for solving the problem.