Yue Ning

0%

Genius User Tutorial

发表于 更新于 分类于 ， ，

what is Genius

Genius is a Java-based negotiation platform to develop general negotiating agents and create negotiation scenarios. The platform can simulate negotiation sessions and tournaments and provides analytical tools to evaluate the agents’ performance

Installation

Requirements

Introduction

How to run

Genius is used in academic research and the international negotiation competition ANAC. In this article IntelliJ is selected to try this Package.

After download Genius, can directly double click file genius-**.jar, open a GUI

After install IntelliJ and configure the system java environment.

How to develop a new Agent in IntelliJ

  1. Start a new Java project on IntelliJ
  2. Add downloaded genius-9.1.11.jar to the project classpath. In “Idea” you can do that by adding it as a library in Module settings (Figure Configuration used for developing the Agent).
  3. Create a new class called SimpleAgent.java and then extend it from the negotiator.Agent class and implement the abstract method called chooseAction(). This method is called whenever our agent needs to perform an action. (i.e.: When the opponent has proposed a bid to the negotiation space, and it’s the turn of our SimpleAgent to either accept it or propose a new bid, then this method will be called.)

   

Configuration used for developing the Agent

Here is a example Agent created by Malintha Fernando

Simple Agent Example 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
import negotiator.*;
import negotiator.actions.Accept;
import negotiator.actions.Action;
import negotiator.actions.EndNegotiation;
import negotiator.actions.Offer;

import java.util.HashMap;
import java.util.Random;
import java.util.logging.Logger;

public class SimpleAgent extends Agent {

    public Action actionOfPartner = null;
    public static Logger log = Logger.getLogger(SimpleAgent.class.getName());
    public Action myLastAction;
    public Bid myLastBid;
    public AgentID agentID;
    public int nOfIssues = 0;
    public HashMap<Bid, Double> utilityCash;

    public enum ActionType {
        START, OFFER, ACCEPT, BREAKOFF
    }

    public ActionType getActionType(Action lAction) {
        ActionType lActionType = ActionType.START;
        if (lAction instanceof Offer)
            lActionType = ActionType.OFFER;
        else if (lAction instanceof Accept)
            lActionType = ActionType.ACCEPT;
        else if (lAction instanceof EndNegotiation)
            lActionType = ActionType.BREAKOFF;
        return lActionType;
    }

    public void init() {
        this.nOfIssues = utilitySpace.getDomain().getIssues().size();
        this.agentID = this.getAgentID();
        this.utilityCash = new HashMap<>();
        BidIterator lIter = new BidIterator(utilitySpace.getDomain());
        while (lIter.hasNext()) {
            Bid tmpBid = lIter.next();
            utilityCash.put(tmpBid, new Double(utilitySpace.getUtility(tmpBid)));
        }
    }

    @Override
    public String getVersion() {
        return "1.0";
    }

    public void ReceiveMessage(Action opponentAction) {
        actionOfPartner = opponentAction;
    }

    @Override
    public Action chooseAction() {
        ActionType lActionType = getActionType(actionOfPartner);
        Action lMyAction = null;
        try {
            switch (lActionType) {
                case OFFER:
                    Offer loffer = ((Offer) actionOfPartner);
                    System.out.println("Opponent's last bid = " + loffer.getBid().toString());
                    if (myLastAction == null) { //this is opponent's initial offer (y0)
                        if (utilitySpace.getUtility(loffer.getBid()) == 1) {
                            lMyAction = new Accept(getAgentID(), loffer.getBid());
                            //i generate my initial offer
                        } else {
                            lMyAction = generateInitialOffer();
                        }
                    } else if (utilitySpace.getUtility(loffer.getBid()) >= utilitySpace.getUtility(((Offer) myLastAction).getBid())) {
                        lMyAction = new Accept(getAgentID(), loffer.getBid());
                        //generate counter offer
                    } else {
                        lMyAction = generateCounterOffer();
                    }
                    break;
                case ACCEPT:
                    break;
                case BREAKOFF:
                    break;
                //I am starting
                default:
                    if (myLastAction == null) {
                        log.info("###default###" + lActionType.name());
                        lMyAction = generateInitialOffer();
                    } else {
                        // simply repeat last action
                        lMyAction = myLastAction;
                        myLastBid = ((Offer) myLastAction).getBid();
                    }
                    break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        myLastAction = lMyAction;
        return lMyAction;
    }

    public Action generateInitialOffer() throws Exception {
        return new Offer(getAgentID(), getBidRandomWalk());
    }

    public Action generateCounterOffer() throws Exception {
        return new Offer(getAgentID(), getBidRandomWalk());
    }

    public Bid getBidRandomWalk() {
        return utilitySpace.getDomain().getRandomBid(new Random());

    }
}

Then compile the project get the SimpleAgent class, open the GUI of Genius, Java -jar genius-9.1.11.jar add the new Agent use class file. (Figure Add New Agent)

Add New Agent

If everything is fine, the can create a negotiation or tournament, use our Agent.

Lucky enough, one of our agents will accept the random bid of the opponent to reach an equilibria.

Reference

Genius
Official Website

Genius: An Integrated Environment for Supporting the Design of Generic Automated Negotiators
RAZLIN,1SARITKRAUS,1,2TIMBAARSLAG,3DMYTROTYKHONOV,3KOENHINDRIKS,3ANDCATHOLIJNM. JONKER3

Writing a simple agent in Genius
Malintha Fernando

Written with StackEdit.