Negotiation User Guide - Interactive Intelligence group
Contents
1. 4 6 2 Run the tournament To run the tournament open a terminal console and change the working directory to the genius directory Then enter this command where yourfile xml is the name of the file you just edited java cp negosimulator jar negotiator xml multipartyrunner Runner yourfile xml Press return when the app prompts you for the log file location to log to the default logs csv file 5 Quality Measures in Genius A large set of quality measures have been incorporated in GENIUS since version 4 0 Most quality measures are automatically available while for others an option must be selected in the tournament options menu There are now two types of logs used in GENIUS the standard log and the tournament log The standard log captures the outcome of each negotiation in a tournament by logging the results of the quality measures for both agents The tournament log uses the standard log to calculate averages and standard deviations of functions of the quality measures in the standard log for example the average final utility for all sessions which resulted in an agreement First Section 5 1 discusses the measures incorporated in the standard log Next Section 5 2 details the tournament log Finally Section 5 3 discusses how Excel can be used to analyze logs 5 1 Overview of Quality Measures in the Standard Log Since version 4 0 GENIUS incorporates two types of quality measures standard measures and detailed measures In2. return SimpleBOAagent 8 8 Advanced Multi Acceptance Criteria MAC The BOA framework allows us to better explore a large space of negotiation strategies MAC can be used to scale down the negotiation space and thereby make it better computationally explorable As discussed in the introduction of this chapter the acceptance condition determines solely if a bid should be accepted This entails that it does not influence the bidding trace except for when it is stopped In fact the only difference between BOA agents where only the acceptance condition vary is the time of agreement assuming that the computational cost of the acceptance conditions are negligible Given this property multiple acceptance criteria can be tested in parallel during the same negotiation trace In practice more than 50 variants of a simple acceptance condition as for example ACnrezt can be tested in the same negotiation at a negligible computational cost To create a multi acceptance condition component you first need to extend the class Mulit Acceptance Condition this gives access to the ACList which is a list of acceptance conditions to be tested in parallel Furthermore the method isMac should be overwritten to return true and the name of the components in the repository should be Multi Acceptance Criteria An acceptance can be added to the MAC by appending it to the AClist as sown below public class AC_MAC extends Multi_AcceptanceCondition Overrid
3. Agent name ANAC 2011 BRAMAgent 7 Timeout Deadline seconds 180 Figure 8 A negotiation session 4 2 Running a Tournament Besides running a single negotiation session it is also possible to run a tournament A tournament can be seen as a collection of sessions In contrast to running a single session the results of a tournament are stored in the log directory These results can be easily analyzed by importing them into Excel cf Section 5 3 A tournament can be created by first selecting Start and then Tournament The Tournament tab will appear similar to Figure 9 This window shows a set of options which we need to specify The value of an option can be specified by double clicking the option in the Values column Tournament Settings Variable Values Alternating Offers Preference profiles etc templates anac y2010 ItexvsCypress ItexvsCypress_Cypress xml etc templates anac y2010 ItexvsCypress ItexvsCypress_Itex xml Agent side A ANAC 2011 HardHeaded Agent side B ANAC 2011 TheNegotiator ANAC 2012 AgentLG ANAC 2012 AgentMR Number of sessions 3 Tournament options showAllBids 0 logFinalAccuracy 0 logDetailedAnalysis 0 disableGUI 0 playBothSides 1 protocolMode 1 showLastBid 0 playAg BOA Agent side A BOA Agent side B Start local tournament Figure 9 Tournament tab e Protocol The set of available protocols e Preference p
4. 15 e numSessions The number of times each session will be run in the tournament e numberOfAgentsPerSession The number of agents to be used for each session e protocolltem Contains the information about the protocol We recommend not to change this as there are no alternative protocols available at this moment e repetitionAllowed If true agents from the partyRepltems negotiate against themselves in the sessions e partyRepltems This element contains a number of lt item gt elements Each of these party items contains the following protocolClassPath We do not support other protocols than negotiator protocol StackedAlternatingOffersProtocol at this moment descriptionA plain text description of this party ClassPath the java party class path to the main class That class must implement the Nego tiationParty interface partyName the plain text name of the party e partyProfileltems This element contains a number of items There must be at least as much as numberOfA gentsPerSession Each item element contains just the url that contains the description of that party profile Usually these URIs have to point to files and therefore are of the form file path to file xml The tournament will consist of sessions created creating all permutations of lt number0fAgentsPerSession gt from the partyRepltems with or without reuse depending on repetitionAllowed The randomization also is applied to the profile items
5. Offer actionOfPartner getBid double offeredUtilFromOpponent getUtility partnerBid get current time double time timeline getTime action chooseRandomBidAction Bid myBid Offer action getBid double myOfferedUtil getUtility myBid accept under certain circumstances if isAcceptable offeredUtilFromOpponent myOfferedUtil time action new Accept getAgentID catch Exception e e printStackTrace action new Accept getAgentID best guess if things go wrong return action 20 The method sAcceptable implements the probabilistic acceptance function Paccept u 2ut 2 t 1 12 u 21 1 Pacet ee 3 where u is the utility of the bid made by the opponent as measured in our utility space and t is the current time as a fraction of the total available time Figure 18 shows how this function behaves depending on the utility and remaining time Note that this function only decides if a bid is acceptable or not More advanced acceptance strategies also use the EndNegotiation action Figure 18 Paccept Value as function of the utility and time as a fraction of the total available time Automatic agents have to negotiate on their own and are not allowed to communicate with a human user Therefore do not override the isUIAgent function in automatic negotiation agents 7 3 General properties Some agents have restrictions and can not be used in certain situation
6. GENIUS As only a single object can be saved and loaded the BOA framework stores an object SessionData that includes the data saved by all three components This object is loaded and saved automatically by the BOA framework A component can easily access the data it saved by using the loadData method A component can at each moment during the negotiation update the saved information by using the storeData method although we recommend updating the information at the end of the negotiation by using the the endSession method The endSession method of each method is automatically called at the end of the negotiation to inform the component of the result obtained and should be used to update the SessionData object before it is automatically stored 8 7 Advanced Converting a BOA Agent to an Agent To convert a BOA agent to a normal agent you have to create a class that extends BOA agent and override the agentSetup method Below is an example of a BOA agent wrapped as a normal agent public class SimpleBOAagent extends BOAagent Override public void agentSetup OpponentModel om new FrequencyModel negotiationSession 0 2 1 OMStrategy oms new NullStrategy negotiationSession OfferingStrategy offering new TimeDependent_Offering negotiationSession om oms 0 2 O 1 0 AcceptanceStrategy ac new AC_Next negotiationSession offering 1 0 setDecoupledComponents ac offering om oms Override public String getName
7. Note that discount factors are part of the preference profiles and therefore different agents may have a different discount factor If a discount factor is present reservation values will be discounted in exactly the same way as the utility of any other outcome It is worth noting that by having a discounted reservation value it may be rational for an agent to end the negotiation early and thereby default to the reservation value 2 Running the Environment The negotiation environment has been tested extensively It should run on any machine running Java 6 or higher including Windows OSX Solaris and Linux distributions Under Ubuntu the jar file should be launched from the terminal to avoid problems with finding the repository files Please report any bugs found to negotiationCii tudelft nl To install the environment the file Genius_release zip can be downloaded Unzip the file at a convenient location on your machine This will result in a package called genius which contains the following files e a doc folder containing userguide pdf which is this document e negosimulator jar the negotiation simulator e a tutorials folder containing various quick start tutorials e afew package folders containing ready to compile agents and components e a javadoc folder containing the complete JavaDoc documentation of Genius When you run the negosimulator by double clicking the application or using open with and then se le
8. Party ID Strategy Preference Add Party Remove Party Timeout Deadline Type Round Max duration 180 Start Figure 15 A multi party negotiation session The following parameters need to be specified to run a negotiation e Negotiation protocol The set of available protocols Normally Alternating Offers is used e A table with participants This table shows all currently added participants e Deadline Type The deadline in use Can be Round or Time e Max duration The maximum duration of the session The units are Round or Time as selected above To modify the table of participants you can either remove or add a party To remove a party select the party in the list and click the Remove Party button To add a party select the correct values for the next party e Party ID The name of the next party to be added e Strategy The ID of the NegotiationParty java class to use for this party e Preference profile The preference profile to be used by the next party to be added After the correct settings have been set press the Add Party button The negotiation is started when you press the start button The tab contents will change to a progress overview panel showing you the results of the negotiation The results are also stored in a log file These results can be easily analyzed by importing them into Excel cf Section 5 3 4 5 Running a Multi Party Tournament A multi party tourna
9. Section 8 The main advantage of a BOA agent is that existing components can be reused allowing for easier agent development Finally to create an agent create a new class and extend the negotiator Agent class Table 3 shows the most important fields and methods of this class For more information please refer to the javadoc of GENIUS To implement your agent you have to override the three methods receiveMessage init and chooseAction An agent may consist of multiple classes as long as one class extends the negotiator Agent class 7 1 Receiving the Opponent s Action The ReceiveMessage Action opponentAction informs you that the opponent just performed the action opponentAction The opponentAction may be null if you are the first to place a bid or an Offer Accept or EndNegotiation action The chooseAction asks you to specify an Action to send to the opponent In the SimpleAgent code the following code is available for ReceiveMessage The SimpleA gent stores the opponent s action to use it when choosing an action public void ReceiveMessage Action opponentAction actionOfPartner opponentAction 19 UtilitySpace utilitySpace The preference profile of the scenario allocated to the agent Timeline timeline Use timeline for every time related by using getTime double getUtility Bid bid A convenience method to get the utility of a bid taking the discount factor into account void init Informs the agent abo
10. one of its bids total CR which equals to CR final utility for this agent ACCR total CR BSCR normalized ACCR ACCR 1 BSCR Append mode and deadline appends the protocol mode and deadline time or rounds to the filename e VISUALIZATION Figure 13 Show all bids When enabled all bids in a scenario are visualized as red points in the negotiation status window This option has some impact on performance Show last bid When enabled the last bid is marked with a special symbol to make it clear which move an agent performed Disable GUI When enabled most GUI elements are disabled This speeds up the negotiation up to a factor of 200 times The progress of the tournament is printed to the console 4 3 Advanced Running a Distributed Tournament A tournament quickly becomes practically too large to run Running a distributed tournament resolves this problem as the tournament is stored in a database Next instances Of GENIUS perhaps running on the same computer can connect to the database and process part of the tournament Before we can run a distributed tournament we first need to setup a simple MySQL server which can be accessed by the computers The installation of the database should include the InnoDB database engine We will use this engine because it allows us to more easily remove old tournament data that 12 SOS Options BOC Options Protocol settings Ses
11. side A Bidding strategy 2011 BRAMAgent Agent side B Bidding strategy 2011 Gahboninho Number of ses Bidding strategy 2011 IAMHaggler2011 Tournament o Bidding strategy 2011 Nice Tit For Tat BOA Agent sid Bidding strategy 2011 ValueModelAgent BOA Agent sid Bidding strateg PTE AgentLG Bidding strategy 2012 gt AgentMR strategy 2012 AgentMR Bidding strategy 2012 BRAMAgent2 Add new component Bidding strategy 2012 CUHKAgent Remove component Bidding strategy 2012 IAMHaggler201z Bidding strategy 2012 OMACagent Bidding strategy 2012 TheNegotiator Reload Bidding strategy Other Better Time dependent Niddina abrata ms thar TALL seadintar Figure 24 The BOA components window Click on the Open button and select the main class file of your BOA component the class file that implements the BOA interface Then check the name of the component you can change it but it has to be a unique name in the registry Optionally add parameters Finally clicking Add component in this window adds the component to the repository Add BOA component F Component class Open O a A Add component Figure 25 Loading a BOA agent 28 8 6 Creating a ANAC2013 BOA Agent In Section 7 7 we discussed how to create an agent for the ANAC2013 Using a similar procedure it is also possible to create BOA agents compatible with ANAC2013 An example to do so is included in this distribution of
12. 3 4 Creating an Opponent Model e 8 3 5 Creating an Opponent Model Strategy e 8 4 Compiling BOA Components 8 5 Adding a Component to the BOA Repository 0 0 0000 eee eee 8 6 Creating a ANAC2013 BOA Age MOTARA A O O NNN 10 11 12 13 14 15 15 16 16 16 17 17 17 18 19 19 19 20 21 21 22 22 23 8 7 Advanced Converting a BOA Agent to an Agent 0 000002 eae 29 8 8 Advanced Multi Acceptance Criteria MAC 29 9 Creating a Multi Party Negotiation Agent 30 9 1 Compiling a Negotiation Party 24 anp o a A a BS A a A 31 OD Loading a Necotiation Party y a EA A A AS a 31 921 Joadse withthe GUL itiaooeee kee de Gee eee bee RES Ge 31 ADA o ACO cc Scie ws 4 Cae Se Gee at ca E Sas ce Ses ae ee ea 31 10 Conclusion 32 1 Theory Crash Course This section provides a crash course on some essential theory needed to understand the negotiation system Furthermore it provides an overview of the features of a negotiation implemented in GENIUS 1 1 Negotiation Objects Agents participating in a negotiation interact in a scenario A scenario specifies the possible bids and their preference for both agents A scenario consists of a domain also called the outcome space and a number of utility spaces also called preference profiles one for each party agent in the negotiation Figure 1 provides an overview of the relation between the doma
13. Model model HashMap lt String Double gt parameters Method directly called after creating the agent which should be used to initialize the component BidDetails getBid List lt BidDetails gt bidsInRange This method returns a bid to be offered from a set of given similarly preferred bids by using the opponent model boolean canUpdate0M Determines if the opponent model may be updated this turn Table 8 The main methods of the opponent model strategy component You can also compile from Eclipse or Netbeans Make sure you add the negosimulator jar to your class path Please refer to the Eclipse or Netbeans documentation on how to do this 8 5 Adding a Component to the BOA Repository In the previous section we discussed how to create each type of BOA component To use the components we still need to add them to the BOA repository To do so open the BOA components tab in the components window as shown in Figure 24 Right click and select Add new component This results in the opening of the window shown in Figure 25 Scenarios Agents BOA components Tour 1 settings 2 Type Name z Tournament Set Bidding strategy 2010 Agent Smith a Bidding strategy 2010 IAMcrazyHaggler a Bidding strategy 2010 IAMHaggler2010 Variable Bidding strategy 2010 Nozomi Protocol Bidding strategy 2010 Yushu Preference prc Bidding strategy 2011 Agent K2 Agent
14. Negotiation User Guide T Baarslag W Pasman K Hindriks D Tykhonov W Visser M Hendrikx D Feirstein August 4 2015 Abstract GENIUS 1 is a negotiation environment that implements an open architecture for heterogeneous nego tiating agents GENIUS can be used to implement or simulate real life negotiations This document describes how you can install the environment work with the provided scenarios and negotiation agents and write compile and run an agent yourself Contents 1 Theory Crash Course Tel Negotiation ODJECU a oe Ee we oe EERE eS ar ae SO 12 Ootima lity Ola Bio eee EE AA Re AAA 13 UINECORIATION TOUOCOM to Se hae Gk care eS de A ER eG ee EES LE Reservation Value 4426 24 92 SAA eke 34 a Ee Tie ti Geol Wisc a a ne is an he sep Se es Ss Sh He CS as OA ee Ds Senos Ses en A oe Gents ak ts ee Se Running the Environment Scenario Creation o Basic GU Components li e ES ee a Se RS ES 32 Creatine a Domal o s ls GM A ye sees Gy e Sw GIN BOR po os B tes ee Ee A 3 3 Creating a Preference Profile 2 2 0 0 0 2 ee a Running Negotiations 4 1 Running a Negotiation Session 1 a a a a 2 Ruano a Tournament se asos p i radar ERA SEGRE EO 421 Tournan Options ds da e ic a ia ad da 43 Advanced Running a Distributed Tournament 2 0008 4 4 Running a Multi Party Negotiation e 4 5 Running a Multi Party Tournament 4 67 Runmne trom the command IDO
15. a HA Move to Column Labels x Y Remove Field 444 Row Labels 9 Value Field Settings agentName bd verage of discountedu mit A Figure 17 Configuration required to summarize the discounted utility of each agent 6 Setting up Java and IDE We assume that you are familiar with programming in Java In case you are not familiar with Java please consult the following tutorial http www oracle com technetwork java javase documentation index html The Java API definitions can be found here as well The recommended way to develop an agent is to create a new project in for example Eclipse or Netbeans To develop GENIUScomponents you will need to add the negosimulator jar as an external library to the project such that classes in the project can use the classes of GENIUS You can copy the negosimulator jar from the zip file into your project space In the examples we will use manual compilation to avoid the need to discuss IDE peculiarities 7 Creating a Bilateral Negotiation Agent This section discusses how to create a basic bilateral negotiation agent in Java Bilateral means you can only use this agent in a two party negotation but not in a multi party negotiation A standard negotiation agent implements an agent as a single block of logic a mix of a bidding strategy acceptance strategy and possibly an opponent model In contrast we recommend to separately implement these components to create a BOA agent as discussed in
16. addition there are some experimental measure types such as competitiveness and opponent model accuracy however these are not discussed here In the following sections we discuss both measure types in detail 16 5 1 1 Standard Measures The standard measures are the measures which are enabled by default and cannot be disabled Table 1 provides an overview of all default quality measures Attribute is not taken into account bestDiscountedA ccepableBid Utility of the best bid offered to the agent taking the discount ee Amount of offers exchanged during the negotiation Time of storage of the result of the negotiation discounted Utility The discounted utility earned by the agent in the negotiation domain Domain at which the negotiation took place _ Domain at which the negotiation took place Errors encountered during the negotiation Not reaching an agreement before the deadline is also treated as an error normalized_utility The final utility divided by the maximum possible utility accord ing to the preference profile In correct domains the result should be equal to the final utility timeOfAgreement Normalized time at which an agreement was established 1 0 for no agreement utilSpace The agent s preference profile Table 1 Standard quality measures in GENIUS in alphabetic order 5 1 2 Detailed Measures The detailed quality measures consist of trajectory analysis measures and measures
17. arted similar to a normal tournament Now other computers can easily connect by specifying the database parameters and selecting Join distributed tournament For these computers we only need to fill in the database parameters as the configuration is loaded from the database Finally after running the full tournament the results are sent to all computers and stored in the log directory Figure 14 summarizes the process Client specifies tournament E T ournament Jobs data data If there are remaining jobs Database Send job results If all jobs are processed Send tournament results Client n Figure 14 Distributed tournament process It should be noted that currently there is no option in GENIUS to delete old tournament data There fore we recommend to install phpMyAdmin Using phpMyAdmin the old data of a tournament can be easily deleted by removing the tournament in the jobs table 4 4 Running a Multi Party Negotiation To run a negotiation session select Start and then Multi Party Negotiation This opens a window similar to Figure 15 13 Sess Editor R Multiparty Negotiation Session Setup Negotiation protocol Stacked Alternating Offers Protocol for Multi Lateral Negotiati Participant Information Party ID Party 1 Strategy Group n Preferences profile etc templates pie pie_A xml
18. ch stores all possible bids and their utilities by using BidIterator In addition it implements efficient search algorithms that can be used to search the space of possible bids for bids near a given utility or within a given utility range e UtilitySpace is a representation of a preference profile It is recommended to use this class when implementing a model of the opponent s preference profile 7 5 Compiling an Agent Compiling an agent can be done as follows here we compile the examplepackage modify as appropriate for your agent e Open a terminal e Switch to the root directory of genius e execute the command javac cp negosimulator jar source 1 6 target 1 6 examplepackage ExampleAgent java You can also compile from Eclipse or Netbeans Make sure you add the negosimulator jar to your class path Please refer to the Eclipse or Netbeans documentation on how to do this Also you can check our tutorial on how to do this from Eclipse 7 6 Loading an Agent The next step is to load the compiled agent in GENIUS We can add the agent in one of the following two ways e Loading the agent using the GUI An agent can be easily added by going to the Agents tab in the Components Window see Figure 19 Next pressing right click opens a popup with the option to add a new agent The final step is to select the main class of your agent Agent Name Description ANAC 2010 IAMcrazyHaggler ANAC 2010 IAMcrazyHagg
19. cting Java progress messages and error messages are printed mainly to the standard output On Mac OSX you can view these messages by opening the console window double click on Systemdisk Applica tions Utilities Console app On Windows this is not directly possible Console output can be read only if you start the application from the console window by hand as follows Go to the directory with the negosimulator and enter java jar negosimulator jar This will start the simulator and all messages will appear in the console window You may see some errors and warnings that are non critical Note that some agents and scenarios require more memory than allocated by default to Java This problem can be resolved by using the Xmx and Xms parameters when launching the executable jar for example java Xmx1536M Xmsi536M jar negosimulator jar 3 Scenario Creation A negotiation can be modeled in GENIUS by creating a scenario A scenario consists of a domain specifying the possible bids and a set of preference profiles corresponding to the preferences of the bids in the domain This section discusses how to create a domain and a preference profile 3 1 Basic GUI Components Start GENIUS by following the instructions in the previous section After starting the simulator a screen similar to Figure 3 is shown This screen is divided in three portions e The Menubar allows us to start a new negotiation e The Components Window shows all available
20. d return a set of BAOparameter objects each parameter having a unique name description and default value public Set lt BOAparameter gt getParameters Override this function to add parameters to the module Table 4 The getParameters method Override if your component has parameters When the component is actually used the actual values for the parameters which may differ from the default are passed to the init function when the component is initialized 8 3 2 Creating a Bidding Strategy A bidding strategy can be easily created by extending the OfferingStrategy class Table 5 depicts the methods which need to be overridden The nit method of the bidding strategy is automatically called by the BOA framework with four parameters the negotiation session the opponent model the opponent model strategy and the parameters of the component The negotiation session object keeps track of the negotiation state which includes all offers made by both agents the timeline the preference profile and the domain The parameters object specifies the parameters as specified in the GUI In the previous section we specified the parameter b for the acceptance strategy Other Next to be 0 0 In this case the agent can retrieve the value of the parameter by calling parameters get b An approach often taken by many bidding strategies is to first generate all possible bids This can be efficiently done by using the SortedOutcomeSpace class For an
21. dalone yes gt lt repository fileName agentrepository xml gt lt items gt lt agentRepItems gt lt agentRepItem description Simple Agent classPath Users wouter Desktop genius examplepackage ExampleAgent class agentName Simple Agent gt params e 2 time 0 95 gt lt agentRepItems gt lt items gt lt filename gt agentrepository xml lt filename gt lt repository gt 7 7 Creating a ANAC2013 Agent The ANAC2013 introduces the concept that an agent can save and load information for each preference profile This entails that an agent can learn from previous negotiations against the same opponent or multiple opponents to improve its competence when having a specific preference profile It is only possible to retrieve information learned on the current preference profile as to avoid having perfect knowledge about the opponent s preferences A single serializable object can be saved per preference profile by using the saveSessionData method If an object was already saved for the preference profile it is replaced We recommend to store objects in the endSession method which is called when a negotiation is finished The saved object can be requested by using the loadSessionData method A good place to do so is in in the nit method Note that this functionality is also available to BOA agents cf Section 8 6 8 Creating a BOA Agent Instead of implementing your negotiating agent from scratch we recomme
22. discuss the two types of agents that can be used automated agents and non automated agents Automated agents are agents that can compete against other agents in a negotiation without relying on input by a user In general these agents are able to make a large amount of bids in a limited amount of time In contrast non automated agents are agents that are fully controlled by the user These types of agents ask the user each round which action they should make GENIUS by default includes the UIA gent which has a simple user interface and the more extensive Extended UIA gent 4 1 Running a Negotiation Session To run a negotiation session select Start and then Negotiation Session This opens a window similar to Figure 8 The following parameters need to be specified to run a negotiation e Negotiation protocol The set of available protocols Normally Alternating Offers is used e Side A Side B The configuration of the agents of both sides e Preference profile The preference profile to be used by the agent of that side e Agent name The agent participating in the negotiation e Deadline seconds The length of the negotiation in seconds Negotiation protocol Alternating Offers 7 Side A Preferences profile etc templates anac y2010 ItexvsCypress ItexvsCypress_Cypress xml 7 Agent name ANAC 2010 IAMcrazyHaggler Y Side B Preferences profile etc templates anac y2010 ItexvsCypress ltexwwsCypress_ltex xml v
23. e link TimeLineInfo about current session param agentID the link AgentID throws RuntimeException if init falle XX A A A A A A A A XA sf public void init UtilitySpace utilSpace Deadline deadline TimeLineInfo timeline long randomSeed AgentID agentID kx When this function is called it is expected that the Party chooses one of the actions from the possible action list and returns an instance of the chosen action x x param possibleActions List of all actions possible return The chosen link Action public Action chooseAction List lt Class lt extends Action gt gt possibleActions This method is called when another link NegotiationParty chose an 30 link Action param sender ihe initiator of the action param arguments The action performed void receiveMessage Object sender Action arguments XX XA A XA gt kx Qreturn a description for this party public String getDescription x Get the protocol that this party supports x return the actual supported link MultilateralProtocol usually link StackedAlternatingOffersProtocol ef public MultilateralProtocolAdapter getProtocol We recommend to use the javadoc included with the distribution to check the details of all the involved classes But in practice it may be more convenient to extend the class negotiator parties AbstractNegotiationParty that provides convenient sup
24. e public void init NegotiationSession negoSession OfferingStrategy strat 29 OpponentModel opponentModel HashMap lt String Double gt parameters throws Exception this negotiationsession negosession this offeringStrategy strat outcomes new ArrayList lt QOutcomeTuple gt ACList new ArrayList lt AcceptanceStrategy gt for int e 0 e lt 5 e ACList add new AC_Next negotiationSession offeringStrategy 1 e 0 01 9 Creating a Multi Party Negotiation Agent This section discusses how to create a multilateral negotiation agent in Java Multilateral means you can use this agent in a multi party negotation and multi party tournament but not in a two party negotiation or tournament Notice that you can still do two party negotiations in the multilateral negotiation and tournament To implement a multi party negotiation party at a minimum one needs to implement a class that implements the textttnegotiator parties NegotiationParty interface Also this class must have a public default no argument constructor To implement the interface one needs to implement five functions public interface NegotiationParty 1 This is the first call made to a NegotiationParty after its instantiation Tells which utility space and timeline we are running in This is called one time only param utilSpace a copy of readonly version of the link UtilitySpace to be used for this session param timeline Th
25. e more agents per session than the number of agents in the pool After you click Start the tournament starts The parties Agents and profiles for each session are determined by created by all possible permuta tions of N agents from the agents pool N is the number of Agents per Session and permutations of N profiles from the profile pool The results of the tournament are shown on screen and also stored in a log file These results can be easily analyzed by importing them into Excel cf Section 5 3 4 6 Running from the command line You can run a multi party tournament from the command line as follows 1 Prepare an xml file that describes the settings for the tournament 2 Run the command runner and give it the prepared file 4 6 1 Prepare the XML settings file Make a copy of the multilateraltournament xml file inside your genius directory and edit it with a plain text editor Inside the lt tournaments gt element you will find a number of lt tournament gt elements Each of these lt tournament gt elements defines a complete tournament so you can run multiple tournaments using one xml file The contents of each lt tournament gt element is as follows e deadline The deadline element contains two values value This is the maximum value determining the deadline Must be an integer gt 1 type Can be either ROUND or TIME If ROUND the value is the number of rounds If TIME value is a time in seconds
26. e standard deviation of this utility between runs e Average of functions of quality measures The tournament log also includes a large set of measures which are functions of measures included in the standard log An example is the average utility for an agent only for the matches which resulted in agreement 5 3 Analyzing Logs using Excel The logs are in XML format which entails that we can easily analyze them by using Excel Note that the following discussion does not apply to the starter edition of Excel as it does not support Pivot tables The XML data of the standard log can be converted to a normal table by importing the data into Excel using the default options This results in a large table showing the result for both agents A and B for each session Analyzing these results manually is complicated therefore we recommend to use pivot tables Pivot tables allow to summarize a large set of data using statistics and can be created by selecting Insert and then Pivot Table To illustrate by dragging the agentName in Row Labels and the discountedUtility in Values see Figure 17 we can easily see which agent scored best in the tournament If solely the amount of matches of each agent is displayed you need to set the Value Field Settings of discountedUtility to average instead of count 18 kalai_distance Drag fields between areas below W Report Filter Move to Report Filter Move to Row Labels E
27. e value for the opponent the average difference between the real estimated pareto bids and their estimated utility for the opponent the amount of real Pareto bids which have been found by the opponent model Note that the estimated utility space may have more or less Pareto bids than there really are the percentage of bids in the estimated Pareto bids which is really Pareto optimal the Pareto frontier distance using the following steps 1 Map the estimated Pareto bids to the real space 2 Calculate the surface beneath the real Pareto bids and estimated Pareto bids 3 Subtract the surfaces and return the absolute difference Note that the Pareto frontier difference can be positive and negative In general the mapped estimate of the Pareto frontier will have less surface however it can happen that less Pareto points were estimated In this case a Pareto point is missed and it can happen that the surface is therefore larger Log competitiveness this computes the amount of discrepancy between the two utility spaces If X is the bid with maximum utility for side B then full yield of A is the utility of X for side A The competitiveness ratio is defined as CR util 1 max fullyield util fullyield 1 fullyield i If this option is enabled the following info is logged for side A and side B x x x x x full yield utility BSCR CR minUtil where minUtil is the minimum utility that an agent asked for in
28. ear interpolation of the utilities of both given utilities The final step is to set the reservation value and discount of a preference profile If you are satisfied with the profile you can save it by pressing Save changes Finally you can create additional preference profiles for the domain and run a negotiation 4 Running Negotiations This section discusses how to run a negotiation There are a number of modes to run a negotiation e Negotiation session A negotiation session concerns a single negotiation in which two agents compete This mode is mainly intended for new users e Tournament A tournament is a collection of sessions Two sets of agents compete against each other on a set of domains The results of the sessions are stored in the log directory These results can be more easily viewed by importing them into Excel and using pivot tables cf Section 5 3 e Distributed tournament A distributed tournament is a tournament which is stored in a database and can therefore be divided among multiple computers to speed up calculation e Multi Party Negotiation A single negotiation session in which a number of agents not neces sarily 2 compete Notice that this is a generalization of the simple Negotiation session above e Multi Party Tournament A tournament of multiparty sessions Again this is a generalization of the tournament above Before going into detail on how each of these modes work we first
29. eoo GENIUS 5 2 10 Start Help ETS Agents BOA components Parties laptop_seller_utility X gt EJ energy_domain xml Name Type Value Weight gt 3 Grocery_domain xml 3 LaptopDomain OBJECTIVE This Objective gt 3 IS_BT_Acquisition xml v laptop_domain xml 7 Laptop DISCRETE 7 laptop_buyer_utility xml 2 Macintosh 30 b l 20 80 Gb 30 121 Mlaptop_seller_utility xml Harddisk DISCRETE m gt 7 Acquisition A domain xml 3 20 LCD 2 23 o i 7 External MoniDISCRETE gt Acquisition B domain xml gt EJ Acquisition C domain xml i i i i S h i 10 i lue gt EJ AirportSiteSelection A domain xml feed save changes cl 92 10 Figure 7 The negosimulator after creating a new utility space For a discrete issue we need to specify the evaluation value of each discrete value A specific value can be assigned any positive non zero integer as evaluation value During the negotiation the utility of a value is determined by dividing the value by the highest value for that particular issue To illustrate if we give 60 Gb evaluation 5 80 Gb evaluation 8 and 120 Gb evaluation 10 then the utilities of these values are respectively 0 5 0 8 and 1 0 Specifying the preference of a integer issue is even easier In this case we simply need to specify the utility of the lowest possible value and the highest possible value The utility of a value in this range is calculated during the negotiation by using lin
30. er using the action ACCEPT The utility of the opponent s last bid is determined for both agents according to their preference profiles The opponent is informed of acceptance via the ReceiveMessage method e The action returned by an agent is ENDNEGOTIATION In this case the score of both agents is set to their reservation value e Finally if an agent does not follow the protocol for instance by sending an action that is not one of the above or by crashing the agent s utility is set to its reservation value whereas the opponent is awarded the utility of the last offer 1 4 Reservation Value A reservation value is a real valued constant that sets a threshold below which a rational agent should not accept any offers Intuitively a reservation value is the utility associated with the Best Alternative to a Negotiated Agreement BATNA A reservation value is the utility that an agent will obtain if no agreement is realized in a negotiation session This can happen either if an agent leaves the negotiation or by not reaching an agreement before the deadline In other words either the negotiating parties agree on an outcome w and both agents receive the associated utility of w or no agreement is reached in which case both agents receive their reservation value instead Reservation values typically differ for each negotiation agent In case no reservation value is set in a profile it is assumed to be 0 1 5 Time Pressure A
31. example on using this class see the TimeDependent_Offering class in the boaexamplepackage directory 8 3 3 Creating an Acceptance Condition This section discusses how to create an acceptance strategy class by extending the abstract class Accep tanceStrategy Table 6 depicts the two methods which need to specified 26 void init NegotiationSession negotiationSession OpponentModel opponentModel OMStrategy omStrategy HashMap lt String Double gt parameters Method directly called after creating the agent which should be used to initialize the component BidDetails determineOpeningBid Method which determines the first bid to be offered to the component BidDetails determineNextBid Method which determines the bids offered to the opponent after the first bid Table 5 The main methods of the bidding strategy component void init NegotiationSession negotiationSession OfferingStrategy offeringStrategy OpponentModel opponentModel HashMap lt String Double gt parameters Method directly called after creating the agent which should be used to initialize the component Actions determineAcceptability Method which determines if the agent should accept the opponent s bid Actions Accept reject it and send a counter offer Actions Reject or leave the negotiation Actions Break Table 6 The main methods of the acceptance strategy component 8 3 4 Creating an Opponent Model This section discusses how to create an oppone
32. for the fairness and optimality of the outcome The detailed measures can be enabled by selecting Log detailed analysis in the tournament options menu Enabling this option also results in the generation of the tournament log discussed in Section 5 2 5 2 Overview of Quality Measures in the Tournament Log The tournament log is an analysis of the results on the quality measures for each agent for example the average utility for Agent K Similar to the detailed quality measured the tournament log can be enabled by selecting Log detailed analysis in the tournament options menu Three types of measures are included in the log e Averages of quality measures The tournament log includes a large set of averages of the quality measures in the standard log Examples include the average Nash distance the average percentage of silent moves and the average social welfare e Standard deviations of quality measures The tournament log also includes the standard deviation of some measures Note that this not the normal standard deviation of for example the 17 Attribute concession_moves The percentage of moves in which the agent relative to the previ ous offer offered a bid with decreased its own utility and increased its opponent s utility exploration_rate The percentage of bids in the outcome space explored by the agent Two bids with exactly the same utilities for both parties are treated as a single same bid fortunate_mo
33. ger issue we first need to specify the lowest possible value and the highest value for example the price range for a second hand car may be 500 700 Next when creating a preference profile we need to specify the utility GENIUS 5 2 10 Start Help Agents BOAcomponents Parties Example X gt pie_domain xml Name Type gt 3 ItexvsCypress_domain xml Example OBJECTIVE This Objective gt EJ party_domain xml gt 3 University xml gt New_sporthal xml gt B Politics xml gt Bank_Robbery xml Add issue HS Remove issue Save changes gt EJ Group4 xml a lel 9 Figure 4 The negosimulator after creating a new Example domain of the lowest possible value 500 and the highest value 700 During the negotiation we can offer any value for the issue within the specified range The next step is to press Ok to add the issue Generally a domain consists of multiple issues We can simply add the other issues by repeating the process above If you are satisfied with the domain you can save it by pressing Save changes Finally note that the issues of a domain can only be edited if the scenario does not yet specify preference profiles This is to avoid inconsistencies between the preference profiles and the domains Basic Properties Basic Properties PRA Name Price Name Harddisk Issue Properties j Integer Issue Properties g Discrete Edit the discrete
34. her the opponent s action should be accepted If the opponent s bid is not accepted by the acceptance strategy then the generated bid is offered instead 24 8 2 Using Existing Components In this section we create a BOA agent by selecting its components from a list of existing components The BOA framework GUI see Figure 21 can be opened by double clicking the Values section next to the BOA Agent side A or BOA Agent side B when creating a distributed tournament OS Select BOA agents Add agent s Edit agent Delete agent BOA Agents F y Save agents a Figure 21 The BOA framework GUI Our goal in this section is to specify three BOA agents which are equal except for a single parameter a of their acceptance strategy To add the agents click on the Add agent s button A dialog pops up to enter the BOA agent details Figure 22 Owe Select BOA agent components and parameters Bidding Strategy Acceptance Strategy Opponent Model Opponent Model Strategy Other Time dependent _ Other Next b lAMhaggler Bayesian Model Random si a 1 0 b 0 0 Change u 0 0 b 1 0 Change t 1 1 Change Figure 22 The BOA agent components and parameters dialog We select the bidding strategy Other Time Dependent under the heading Bidding Strategy Note that when we select this strategy the default parameters of the component appear in the textbox below Next we select the other three com
35. honov Koen V Hindriks and Catholijn M Jonker Genius An integrated environment for supporting the design of generic automated negotiators Computational Intelligence 2012 32
36. in and the utility space of an agent Domain Utility Space Figure 1 Overview of the data structures and relations The Domain describes which issues are the subject of the negotiation and which values an issue can attain A domain contains n issues D 1 I Each issue i consists of k values I vi vi Combining these concepts an agent can formulate a Bid a mapping from each issue to a chosen value denoted by c b vi v7 To give an example in the laptop domain the issues are laptop harddisk and monitor In this domain the issues can only attain discrete values e g the harddisk issue can only have the values 60 Gb 80 Gb and 120 Gb These issues are all instance of IssueDiscrete A valid bid in the laptop domain is a Dell laptop with 80 Gb and a 17 inch monitor The Utility Space specifies the preferences of the bids for an agent using an evaluator The evaluator of an issue maps the evaluation of an issue value which is specified in the preference profile to a utility for that issue The evaluator also specifies the importance of the issue relative to the other issues in the form of a weight The weights of all issues sum up to 1 0 to simplify calculating the utility of a bid To illustrate the harddisk issue is of the type ssueDiscrete and therefore its evaluator is of the type EvaluatorDiscrete In general given the set of all bids there are a smal
37. is Enabling this option activates a set of quality measures to capture the quality of the negotiation process The quality measures are added to the default log In addition for the whole tournament an overview log is created This log is prefixed with TM Log negotiation trace If enabled a more extensive log is written including the bid history to a file having the name extensive_log xml Log final accuracy Logs the accuracy of the final opponent model of BOA agents on side A This is done by comparing the opponent model of side A with the actual utility space of side B Calculated are 11 the Pearson correlation coefficient by comparing the utility of each bid estimated by the real and estimated opponent s utility space Higher is better the ranking distance by comparing the utility of each bid estimated by the real and esti mated opponent s utility space Lower is better the ranking distance by comparing the utility of each weight estimated by the real and estimated opponent s utility space Lower is better average difference between the real and estimated utility average difference between the real and estimated issue weights the absolute difference between the estimated Kalai point and the real Kalai point Note that we are only interested in the value for the opponent the absolute difference between the estimated Nash point and the real Nash point Note that we are only interested in th
38. is entails that an agent does not know which bid the opponent prefers given a set of bids This problem can be partly resolved by building an opponent model of the opponent s preferences by analyzing the negotiation trace Each turn the agent can now offer the best bid for the opponent given a set of similar preferred bids GENIUSprovides a number of components that can estimate an opponent model 1 3 Negotiation Protocol The negotiation protocol determines the overall order of actions during a negotiation Agents are obliged to stick to this protocol as deviations from the protocol are caught and penalized This section discusses the details of the bilateral alternating offers protocol used in GENIUS In the bilateral alternating offers protocol two parties agent A and agent B take turns Agent A starts the negotiation Each turn an agent presents one of the three possible actions ACCEPT This action indicates that agent accepts the opponent s last bid OFFER This action represents the bid made by an agent ENDNEGOTIATION This action indicates that the agent terminates the negotiation When it is an agent s turn it is informed about the opponent s action Based on the opponent s action the agent comes up with an action which it presents to the opponent Sequentially the opponent presents a counter action This process goes on until the negotiation finishes in one of the following ways e An agent accepts the opponent s off
39. l subset of bids which are more preferred as outcomes by both agents Identifying these special bids may lead to a better agreement for both parties We discuss the optimality of a bid in the next section 1 2 Optimality of a Bid Each value of a bid is assigned an evaluation value eval v in the utility space The utility is the weighted sum of the scaled evaluation values al 02 y OS _ 1 max eval 1 For a single agent the optimal bid is of maximum utility for the agent Often this bid has a low utility for the opponent and therefore the chance of agreement is low A more general notion of optimality of a negotiation involves the utility of both agents 1 0 Unavailable Agent B 0 0 Agent A 1 0 Figure 2 A point indicates the utility for both agents of a bid The red line is the Pareto optimal frontier There are multiple ways to define a more global optimum One approach to optimality is that a bid is not optimal for both parties if there is another bid that has the higher utility for one party and at least equal utility for the other party Thus only bids in Figure 2 for which there is no other bid at the top right is optimal This type of optimality is called Pareto optimality and forms an important concept in automated negotiation The collection of Pareto optimal bids is called the Pareto optimal frontier A major challenge in a negotiation is that agents can hide their preferences Th
40. ler ANAC 2010 AgentSmith ANAC 2010 AgentSmith ANAC 2010 Nozomi ANAC 2010 Nozomi ANAC 2011 TheNegotiator ANAC 2011 TheNegotiator ANAC 2011 ValueModelAgent ANAC 2011 ValueModelAgent BRAMAgent ANAC 2011 HardHeaded ANAC Add new agent ANAC 2011 IAMhaggler2011 ANAC Remove agent ANAC 2011 AgentK2 ANAC eorr rigere ANAC 2012 AgentLG ANAC 2012 AgentLG ANAC 2012 AgentMR ANAC 2012 AgentMR Figure 19 Adding an agent using the GUI e Loading the agent using XML A compiled agent can also be loaded by directly adding the agent to the repository using the agentrepository xml file The code below visualizes a repository with a single agent An agent element consists of several subelements the first element is the description of the agent which is visualized in the GUI The second element is the classPath specifying were the compiled agent class is located For built in agents this is the class name but for user defined agents this is the full filename of the main class of the agent the one implementing the Agent interface The third element specifies the agentName The optional element params specifies the parameters and their values available to the agent In this case a parameter e with value 2 and a parameter time with value 0 95 is specified Variables can be accessed during the negotiation by using the getStrategyParameters method 22 lt xml version 1 0 encoding UTF 8 stan
41. ment is a set of multi party sessions To prepare a multi party tournament select Start and then Multi Party Tournament The Tournament tab will appear similar to Figure 16 This window shows a set of options which we need to specify e Protocol The protocol to use for each session e Deadline The limits on time and number of rounds for each session e Number of tournaments The number of times the entire tournament will be run e Agents per Session The number of agents N to use for each session e Agent Repetition Allowed Determines if agents are put back into the pool of agents after a run 14 Multilateral Negotiation Tournament Setup Environment Protocol Stacked Alternating Offers Protocol for Multi Lateral Negotiation SAOPMN Deadline time 180 Number of Tournaments 1115 Agents per Session 2115 Agent Repetition Allowed Agents Profiles Add Remove Clear Add Remove Clear Start Tournament Figure 16 Multi Party Tournament e Agents The pool of agents to draw from Click Add to select the set of agents to put into the pool Select an agent and click remove to remove an agent from the pool Click Clear to clear the pool e Profiles The set of profiles to draw from Click Add to select the set of profiles to put in the pool Select a profile and click Remove to remove a profile from the pool Click Clear to clear the pool This option disables if there ar
42. nd you create a BOA agent using the BOA framework The BOA negotiation agent architecture allows to reuse existing components from other BOA agents Many of the sophisticated agent strategies that currently exist are comprised of a fixed set of modules Generally a distinction can be made between four different modules one module that decides whether the opponent s bid is acceptable acceptance strategy one that decides which set of bids could be proposed next bidding strategy one that tries to guess the opponent s preferences opponent model and finally a component which specifies how the opponent model is used to select a bid for the opponent opponent model strategy The overall negotiation strategy is a result of the interaction between these components The advantages of separating the negotiation strategy into these four components or equivalently fitting an agent into the BOA framework are threefold first it allows to study the performance of indi vidual components second it allows to systematically explore the space of possible negotiation strategies third the reuse of existing components simplifies the creation of new negotiation strategies 8 1 Components of the BOA Framework A negotiation agent in the BOA framework called a BOA agent consists of four components Bidding strategy A bidding strategy is a mapping which maps a negotiation trace to a bid The bidding strategy can interact with the opponent model by con
43. negotiation lasts a predefined time in seconds or alternatively rounds In GENIUS the time line is normalized i e time t 0 1 where t 0 represents the start of the negotiation and t 1 represents the deadline Notice that manipulation of the remaining time can be a factor influencing the outcome There is an important difference between a time based and rounds based protocol In a time based protocol the computational cost of an agent should be taken into account as it directly influences the amount of bids which can be made In contrast for a rounds based negotiation the time can be thought of as paused within a round therefore computational cost does not play a role Apart from a deadline a scenario may also feature discount factors Discount factors decrease the utility of the bids under negotiation as time passes While time is shared between both agents the discount generally differs per agent The implementation of discount factors is as follows let d in 0 1 be the discount factor that is specified in the preference profile of an agent let t in 0 1 be the current normalized time as defined by the timeline we compute the discounted utility Up of an outcome w from the undiscounted utility function U as follows Up w U w d 2 If d 1 the utility is not affected by time and such a scenario is considered to be undiscounted while if d is very small there is high pressure on the agents to reach an agreement
44. nt model by extending the abstract class OpponentModel Table 7 provides an overview of the main methods which need to specified For performance reasons it is recommended to use the UtilitySpace class void init NegotiationSession negotiationSession HashMap lt String Double gt parameters Method directly called after creating the agent which should be used to initialize the component double getBidEvaluation Bid bid Returns the estimated utility of the given bid double updateModel Bid bid Updates the opponent model using the given bid UtilitySpace getOpponentUtilitySpace Returns the opponent s preference profile Use the UtilitySpaceAdapter class when not using the UtilitySpace class for the opponent s preference profile Table 7 The main methods of the opponent model component 8 3 5 Creating an Opponent Model Strategy This section discusses how to create an opponent model strategy by extending the abstract class OM Strategy Table 8 provides an overview of the main methods which need to specified 8 4 Compiling BOA Components BOA components must be compiled before they can be loaded into Genius To compile a BOA component do the following steps in this example we compile the boa example components e Open a terminal e Switch to the root directory of genius e Enter the command javac cp negosimulator jar source 1 6 target 1 6 boaexamplepackage java vat void init NegotiationSession negotiationSession Opponent
45. pita el AS oe A a 4 6 1 Prepare the XML settings file o 40 2 R nthe tournament s sop siea miea Go Ae a ee AA A A A ES Quality Measures in Genius 5 1 Overview of Quality Measures in the Standard Log SLI Standard Measures ss rc ae eh e dai we arte oh ES Hae Detaled Measures 376 2 dk w Ed Y Se do O A ae aE wide 5 2 Overview of Quality Measures in the Tournament Log 5 3 Analyzing Logs using Excel 2 2 364 woe Bae Be he Ae RO REE SRE SE ES Setting up Java and IDE Creating a Bilateral Negotiation Agent 7 1 Receiving the Opponent s Action T2 AMO OSMA ai SCO ais eee ae oe he A ee a a A ee toot General Properties e Sew an Hh Berk ue ge Se Gy ew ke Der BR Oe ge A oe ew ee ere TA Overview of Classes soi dwt ads Be hw a ee hee Be ee ai 97 CoOmpilinecan ACen jy gk is dr wee Met Oe te et aaa era oe ee ee oe eee O Coadic anr A enli 6 2m tre gd 4 Bo eae AG eee tS EE Ae EE eet eS 4 7 7 Creating a ANAC2013 Agent sexies 84h 2 eR bee PRE EERE Creating a BOA Agent 8 1 Components of the BOA Framework 0 0 00 0 ee eee 2 sine Existing Components gt ao la a ee BO OR a a ee o EE ES 8 3 Creating New Components o eativa Y ee ed dr SS Rr Eee a SL Parameters ma ou gee Va ERE BREA ER SE he AAA eS oe So Creating a Bidding Strategy a 44 devastada 8 3 3 Creating an Acceptance Condition aoao s a a e 444 04 64005 a 8
46. ponents shown in Figure 22 The next step is to specify three variants of the acceptance strategy differing in the parameter a To be more precise we want a to be 1 0 1 1 and 1 2 To achieve this press the Change button under Acceptance Strategy to open a window similar to Figure 23 Next fill in the fields as shown in Figure 23 Finally we select Add agent s to create the three agents Press Save agents to save the new BOA agents for the tournament Note that in this example we only varied a single parameter of a single component If we vary more parameters possibly of different components then all possible combinations are generated 20 QO Edit parameters Description Lower bound Step size Upper bound a a bis greater than the utility of our current bid 1 0 0 1 1 2 b a bis greater than the utility of our current bid 0 0 Ok Cancel Figure 23 Adding a parameter 8 3 Creating New Components This section discusses how create your own components An example implementation of each component is included in the boaexamplepackage folder The next section discusses how these components can be added to the list of available components in the BOA framework GUI 8 3 1 Parameters All BOA components have the same mechanism to be tuned with parameters The parameters and their default parameters are indicated by the component by overriding the getParameters function This function shoul
47. port functions The functions receiveMessage and chooseAction are basically the same as described in section 7 1 and 7 2 getProtocol usually returns an instance of StackedAlternatingOffersProtocol 9 1 Compiling a NegotiationParty To compile the example agent go to your genius project folder and use the command line to execute this compile command javac cp negosimulator jar source 1 6 target 1 6 multipartyexample Groupn java 9 2 Loading a NegotiationParty You need to load your custom party into the party repository in order to use it After adding your agent will appear in the combo boxes in the multilateral tournament runner and session runner where you can select the party to use You can load the new NegotiationParty into the party repository in two ways 9 2 1 loading with the GUI Locate the Parties repository tab in the GUI Figure 26 Right click in this area and select Add Party A browser window pops up Brows to your compiled class file that implements the NegotiationParty and select it Your party will appear at the bottom of the parties repository The partyrepository xml file is automatically updated accordingly 9 2 2 manual loading To do this manually quit GENIUS open the partyrepository xml file and add a section like this lt partyRepltem description description for your agent classPath class of your agent partyName nameForYourAgent protocolClassPath negotiator protocol StackedAlternatingUOffe
48. rofiles The set of scenarios on which the agents should compete Each selected scenario should feature at least two preference profiles e Agent side A B The set of agents in set A competes against all agents in set B e Number of sessions The number of times each session should be repeated e Tournament options Options which specify how to run the tournament see below e BOA Agent side A B Type of agents that consist of multiple components see Section 8 10 4 2 1 Tournament Options A large set of tournament options can be specified which influence the composition and running of the tournament There are four categories of options e PROTOCOL SETTINGS Figure 10 Protocol mode Specifies if the negotiation features rounds or time In a time based negotiation there is an amount of time to reach an agreement Time passes while an agent deliberates an action In contrast in a rounds based negotiation the deadline is specified in rounds An agent can take more time to compute an action as time does not pass within a round Deadline Depending on the protocol mode this is the maximum amount of time in seconds or amount of rounds Note that one single round corresponds to one turn of a single agent Access partner preferences Allows agents to access the preference profile of the negotiation session which contains the opponent s preference profile One sided bidding If enabled then agent A s bids are ignored and replaced by
49. rsProtocol gt l AAA DS o GENIUS 5 2 9 Start Help Scenarios Agents BOA components Parties Party Name Description Protocol Boulware Deadline based boulware agent StackedAlternatingOffersProtocol Conceder Deadline based conceder agent StackedAlternatingOffersProtocol Ul Party Simple Ul party StackedAlternatingOffersProtocol Random party Random party StackedAlternatingOffersProtocol NDConceder Non deterministic conceder StackedAlternatingOffersProtocol ANAC2015 1 Phoenix 1 Phoenix StackedAlternatingOffersProtocol ANAC2015 2 CUHK 2 CUHK StackedAlternatingOffersProtocol ANAC2015 3 ParsAgent 3 ParsAgent StackedAlternatingOffersProtocol ANAC2015 4 Ares 4 Ares StackedAlternatingOffersProtocol ANAC2015 5 Mercury 5 Mercury StackedAlternatingOffersProtocol ANAC2015 6 Atlas 6 Atlas StackedAlternatingOffersProtocol ANAC2015 7 AgentH 7 AgentH StackedAlternatingOffersProtocol ANAC2015 8 SENGOKU 8 SENGOKU StackedAlternatingOffersProtocol ANAC2015 9 AgentW 9 AgentW StackedAlternatingOffersProtocol Figure 26 The parties repository After that you can restart GENIUS 10 Conclusion This concludes the manual of GENIUS If you experience problems or have suggestions on how to improve GENIUS please send them to negotiationCii tudelft nl GENIUS is actively used in academic research If you want to cite GENIUS in your paper please refer to 1 References 1 Raz Lin Sarit Kraus Tim Baarslag Dmytro Tyk
50. s The agent indicates its capabil ities through the function getSupportedNegotiationSetting By default the agent has no restrictions If your agent has restrictions you must override this function and return the appropriate supported settings For example if your agent can only handle linear utility spaces you should override like this Override public SupportedNegotiationSetting getSupportedNegotiationSetting return SupportedNegotiationSetting getLinearUtilitySpacelnstance 7 4 Overview of Classes This section provides an overview of classes which might be useful when implementing an agent For the documentation of the data structures that are presented please refer to the Javadoc that can be found in your download of GENIUS e BidDetails is a structure to store a bid and its utility e BidDetailsTime is a structure to store a bid its utility and the time of offering e BidHistory is a structure to keep track of the bids presented by the agent and the opponent BidIterator is a class used to enumerate all possible bids Also refer to SortedOutcomeSpace 21 e BidSpace is a class which can be used to determine the Pareto optimal frontier and outcomes such as the Nash solution This class can be used with the opponent s utility space as estimated by an opponent model e Pair is a simple pair of two objects e Range is a structure used to describe a continuous range e SortedOutcomeSpace is a structure whi
51. scenarios agents and BOA components e The Status Window shows the negotiation status or selected domain preference profile eoo GENIUS 5 2 10 Start Help Agents BOA components Parties gt Ed pie_domain xml gt 3 ItexvsCypress_domain xml gt ES party_domain xml gt B University xml gt B New_sporthal xml gt Politics xml gt 3 Bank_Robbery xml Figure 3 The negosimulator right after start up The left half is the components panel the right half the status panel 3 2 Creating a Domain By right clicking on the list of available scenarios in the Components Window a popup menu with the option to create a new domain is shown After clicking this option it is requested how the domain should be called Next the domain is automatically created and a window similar to Figure 4 is shown Initially a domain contains zero issues We can simply add an issue by pressing the Add issue button This results in the opening of a dialog similar to Figure 5 The current version of GENIUS supports the creation of discrete and integer issues Starting with a discrete issue the values of the issue should be specified In Figure 5 we show the values of the issue Harddisk Note the empty evaluation values window later on when creating a preference profile we will use this tab to specify the preference of each value Instead of a discrete issue we can also add an integer issue as shown in Figure 6 For an inte
52. sion generation Logging Visualization Protocol settings Session generation Logging _ Visualization Log detailed analysis O Show all bids mM Log negotiation trace Show last bid Y Log final accuracy Disable GUI Log competitiveness Q Append mode and deadline O Ok Cancel Reset to default Ok Cancel Reset to default gt Figure 12 Protocol Settings Figure 13 Session Generation options we no longer need Furthermore we recommend at least 50 Mb of free space The required database structure can be created by using the SQL dump which can be found in the directory doc database The next step is to specify a tournament to run Towards this end select Start and then Dis tributed tournament This opens a GUI similar to Figure 9 except for the following four options e Database address The address of the database for example sql ewi tudelft nl 3306 DG e Database user The username of the account for the database e Database password The password of the user account for the database e Database sessionname The identifier of the tournament The identifier is needed as multiple distributed tournaments can be run at the same time After specifying the tournament and database parameters we can start the distributed tournament by pressing Start distributed tournament Selecting this button splits the tournament into smaller jobs which are stored in the database The tournament is automatically st
53. sulting with it Opponent model An opponent model is in the BOA framework a learning technique that constructs a model of the opponent s preference profile Opponent model strategy An opponent model strategy specifies how the opponent model is used to select a bid for the opponent and if the opponent model may be updated in a specific turn Acceptance strategy The acceptance strategy determines whether the opponent s bid is acceptable and may even decide to prematurely end the negotiation 23 Opponent Model Pak Strategy y Bidding Strategy gt Acceptance Strategy Bidding History Negotiation Environment Components a Action BOA Components Figure 20 The BOA Framework Architecture The components interact in the following way the full process is visualized in Figure 20 When receiving a bid the BOA agent first updates the bidding history Next the opponent model strategy is consulted if the opponent model may be updated this turn If so the opponent model is updated Given the opponent s bid the bidding strategy determines the counter offer by first generating a set of bids with a similar preference for the agent The bidding strategy uses the opponent model strategy to select a bid from this set taking the opponent s utility into account Finally the acceptance strategy decides whet
54. the bid that has max utility for A agent A s accepts are passed through Allow pausing timeline Allow agents to pause the negotiation by using the timeline pause and time resume methods e SESSION GENERATION Figure 11 Play both sides When generating the sessions whether each pair of agents should play both sides on a scenario or not Play against self An agent may be included both in the set Agent side A and side B If this option is enabled an agent is allowed to play against itself If disabled the sessions in which agents negotiate against themselves are removed Starting agent This agent has to place the first bid Generation mode Standard or Random If set to random the generated sessions are shuffled into a random order using the random seed Random seed Random seed used for shuffling sessions HOYO Options BOL Options Protocol settings Session generation Logging Visualization Protocol settings Session generation Logging Visualization Protocol mode Play both sides a Deadline seconds 100 Play against self Access partner preferences Starting agent A B One sided biddi a B ne sided bidding Generation mode Standard Allow pausing timeline Random seed Ok Cancel Reset to default Ok Cancel Reset to default Ne a o o Ne o A Figure 10 Protocol Settings Figure 11 Session Generation options e LOGGING Figure 12 Log detailed analys
55. ut beginning of a new negotiation session void ReceiveMessage Action opponentAction Informs the agent which action the opponent did Action chooseAction This function should return the action your agent wants to make next String getName Returns the name of the agent Please override this to give a proper name to your agent Table 3 The most important methods and fields of the Agent class 7 2 Choosing an Action The code block below shows the code of the method chooseAction for SimpleAgent For safety all code was wrapped in a try catch block because if our code would accidentally contain a bug we still want to return a good action failure to do so is a protocol error and results in a utility of 0 0 The sample code works as follows If we are the first to place a bid we place a random bid with sufficient utility see the java file for the details on that Else we determine the probability to accept the bid depending on the utility of the offered bid and the remaining time Finally we randomly accept or pose a new random bid While this strategy works in general it will lead to suboptimal results as it does not take the opponent into account More advanced agents try to model the opponent s strategy or preference profile public Action chooseAction Action action null try 4 if CactionOfPartner null 4 action chooseRandomBidAction if action0fPartner instanceof Offer Bid partnerBid
56. values below Minimum value Evaluation of minimum value Maximum value Evaluation of maximum value ok canst Figure 5 Creating a discrete issue Figure 6 Creating an integer issue 3 3 Creating a Preference Profile Now that we created a domain the next step is to add a set of preference profiles By right clicking on the domain a popup menu is opened which has an option to create a new preference profile Selecting this option results in the opening of a new window which looks similar to Figure 7 Now you are ready to start customizing the preference profile There are three steps setting the importance of the issues determining the preference of the values of the issues and configuring the reservation value and discount To start with the first step you can adjust the relative weights of the issues by using the sliders next to that issue Note that when you move a slider the weights of the other sliders are automatically updated such that the all weights still sum up to one If you do not want that the weight of another issue automatically changes you can lock its weight by selecting the checkbox behind it Now that we set the weights of the issues it is a good idea to save the utility space The next and final step is to set the evaluation of the issues To specify the evaluation of an issue you can double click it to open a new window looking similar to Figure 5 or Figure 6 depending on the type of the issue
57. ves The percentage of moves in which the agent relative to the pre vious offer offered a bid which increased both its own and its opponent s utility joint_exploration_bids The percentage of unique bids of the outcome space explored by both agents together Two bids with exactly the same utilities for both parties are treated as a single same bid Kalai Smorodinsky solution Nash solution nice_moves The percentage of moves in which the agent relative to the pre vious offer offered a bid which increased its opponent s utility without significantly changing its own utility nearest bid on the Pareto optimal frontier selfish_moves The percentage of moves in which the agent relative to the pre vious offer offered a bid which increased its own utility and de creased its opponent s utility silent_moves The percentage of moves in which the agent relative to the pre vious offer offered a bid which which was nearly equally valued by both agents A fairness measure being the sum of the utilities for both agents unfortunate_moves The percentage of moves in which the agent relative to the pre vious offer offered a bid which decreased both its own and its opponent s utility Table 2 Detailed quality measures in GENIUS in alphabetic order utility but the more complicated deviation between runs To illustrate if there were ten runs of the tournament then each run has an average utility and we can calculate th
Download Pdf Manuals
Related Search