source: src/main/java/agents/SimpleAgentSavingBidHistory.java@ 126

Last change on this file since 126 was 126, checked in by Aron Hammond, 6 years ago

Added function to calculate opposition to MultiLateralAnalysis.java

Moved code to add RLBOA listeners to RLBOAUtils is misc package

Added input for strategyParameters to SessionPanel (gui)

!! close SessionInfo after tournament; this caused /tmp/ to fill up with GeniusData files

Our own package:

  • Added opponents and strategies that are mentioned in the report
  • Change class hierarchy, agents can now extend from RLBOAagentBilateral to inherit RL functionality.
  • States extend from AbstractState
File size: 8.9 KB
Line 
1package agents;
2
3import java.io.Serializable;
4import java.util.HashMap;
5import java.util.List;
6import java.util.Random;
7
8import genius.core.Agent;
9import genius.core.Bid;
10import genius.core.BidHistory;
11import genius.core.actions.Accept;
12import genius.core.actions.Action;
13import genius.core.actions.EndNegotiation;
14import genius.core.actions.Offer;
15import genius.core.bidding.BidDetails;
16import genius.core.issue.Issue;
17import genius.core.issue.IssueDiscrete;
18import genius.core.issue.IssueInteger;
19import genius.core.issue.IssueReal;
20import genius.core.issue.Value;
21import genius.core.issue.ValueInteger;
22import genius.core.issue.ValueReal;
23
24/**
25 * @author S. Hourmann Some improvements over the standard Agent. Saving Bid
26 * History for the session.
27 *
28 * Random Walker, Zero Intelligence Agent
29 */
30public class SimpleAgentSavingBidHistory extends Agent {
31 // "state" represents "where am I in the code".
32 // I want to print "state" when I print a message about saving data.
33 private String state;
34 private Action actionOfPartner = null;
35
36 /**
37 * Note: {@link SimpleAgentSavingBidHistory} does not account for the
38 * discount factor in its computations
39 */
40 private static double MINIMUM_BID_UTILITY = 0.0;
41
42 private BidHistory currSessOppBidHistory;
43 private BidHistory prevSessOppBidHistory;
44
45 public SimpleAgentSavingBidHistory() {
46 super();
47 this.currSessOppBidHistory = new BidHistory();
48 }
49
50 /**
51 * init is called when a next session starts with the same opponent.
52 */
53 public void init() {
54 MINIMUM_BID_UTILITY = utilitySpace.getReservationValueUndiscounted();
55 myBeginSession();
56 }
57
58 public void myBeginSession() {
59 System.out.println("Starting match num: " + sessionNr);
60
61 // ---- Code for trying save and load functionality
62 // First try to load saved data
63 // ---- Loading from agent's function "loadSessionData"
64 Serializable prev = this.loadSessionData();
65 if (!(prev == null)) {
66 prevSessOppBidHistory = (BidHistory) prev;
67 System.out
68 .println("---------/////////// NEW NEW NEW /////////////----------");
69 System.out.println("The size of the previous BidHistory is: "
70 + prevSessOppBidHistory.size());
71 } else {
72 // If didn't succeed, it means there is no data for this preference
73 // profile
74 // in this domain.
75 System.out.println("There is no history yet.");
76 }
77 }
78
79 @Override
80 public String getVersion() {
81 return "3.1";
82 }
83
84 @Override
85 public String getName() {
86 return "Simple Agent Saving Bid History";
87 }
88
89 public void ReceiveMessage(Action opponentAction) {
90 actionOfPartner = opponentAction;
91 if (opponentAction instanceof Offer) {
92 Bid bid = ((Offer) opponentAction).getBid();
93 // 2. store the opponent's trace
94 try {
95 BidDetails opponentBid = new BidDetails(bid,
96 utilitySpace.getUtility(bid), timeline.getTime());
97 currSessOppBidHistory.add(opponentBid);
98 } catch (Exception e) {
99 e.printStackTrace();
100 }
101 }
102 }
103
104 public Action chooseAction() {
105 Action action = null;
106 Bid partnerBid = null;
107 try {
108 if (actionOfPartner == null)
109 action = chooseRandomBidAction();
110 if (actionOfPartner instanceof Offer) {
111 partnerBid = ((Offer) actionOfPartner).getBid();
112 double offeredUtilFromOpponent = getUtility(partnerBid);
113 // get current time
114 double time = timeline.getTime();
115 action = chooseRandomBidAction();
116
117 Bid myBid = ((Offer) action).getBid();
118 double myOfferedUtil = getUtility(myBid);
119
120 // accept under certain circumstances
121 if (isAcceptable(offeredUtilFromOpponent, myOfferedUtil, time)) {
122 action = new Accept(getAgentID(), partnerBid);
123
124 // ---- Code for trying save and load functionality
125 // /////////////////////////////////
126 state = "I accepted so I'm trying to save. ";
127 tryToSaveAndPrintState();
128 // /////////////////////////////////
129
130 }
131 }
132 if (actionOfPartner instanceof EndNegotiation) {
133
134 // ---- Code for trying save and load functionality
135 // /////////////////////////////////
136 state = "Got EndNegotiation from opponentttttttttt. ";
137 tryToSaveAndPrintState();
138 // /////////////////////////////////
139 }
140 sleep(0.005); // just for fun
141 } catch (Exception e) {
142 System.out.println("Exception in ChooseAction:" + e.getMessage());
143
144 // ---- Code for trying save and load functionality
145 // /////////////////////////////////
146 state = "Got Exceptionnnnnnnnnn. ";
147 tryToSaveAndPrintState();
148 // /////////////////////////////////
149 // best guess if things go wrong.
150 action = new Accept(getAgentID(), partnerBid);
151 }
152 return action;
153 }
154
155 // ---- Code for trying save and load functionality
156 private void tryToSaveAndPrintState() {
157
158 // ---- Saving from agent's function "saveSessionData"
159 this.saveSessionData(currSessOppBidHistory);
160 System.out.println(state + "The size of the BidHistory I'm saving is: "
161 + currSessOppBidHistory.size());
162 }
163
164 private boolean isAcceptable(double offeredUtilFromOpponent,
165 double myOfferedUtil, double time) throws Exception {
166 double P = Paccept(offeredUtilFromOpponent, time);
167 if (P > Math.random())
168 return true;
169 return false;
170 }
171
172 /**
173 * Wrapper for getRandomBid, for convenience.
174 *
175 * @return new Action(Bid(..)), with bid utility > MINIMUM_BID_UTIL. If a
176 * problem occurs, it returns an Accept() action.
177 */
178 private Action chooseRandomBidAction() {
179 Bid nextBid = null;
180 try {
181 nextBid = getRandomBid();
182 } catch (Exception e) {
183 System.out.println("Problem with received bid:" + e.getMessage()
184 + ". cancelling bidding");
185 }
186 if (nextBid == null)
187 return (new Accept(getAgentID(), currSessOppBidHistory.getLastBid()));
188 return (new Offer(getAgentID(), nextBid));
189 }
190
191 /**
192 * @return a random bid with high enough utility value.
193 * @throws Exception
194 * if we can't compute the utility (eg no evaluators have been
195 * set) or when other evaluators than a DiscreteEvaluator are
196 * present in the util space.
197 */
198 private Bid getRandomBid() throws Exception {
199 HashMap<Integer, Value> values = new HashMap<Integer, Value>(); // pairs
200 // <issuenumber,chosen
201 // value
202 // string>
203 List<Issue> issues = utilitySpace.getDomain().getIssues();
204 Random randomnr = new Random();
205
206 // createFrom a random bid with utility>MINIMUM_BID_UTIL.
207 // note that this may never succeed if you set MINIMUM too high!!!
208 // in that case we will search for a bid till the time is up (3 minutes)
209 // but this is just a simple agent.
210 Bid bid = null;
211 do {
212 for (Issue lIssue : issues) {
213 switch (lIssue.getType()) {
214 case DISCRETE:
215 IssueDiscrete lIssueDiscrete = (IssueDiscrete) lIssue;
216 int optionIndex = randomnr.nextInt(lIssueDiscrete
217 .getNumberOfValues());
218 values.put(lIssue.getNumber(),
219 lIssueDiscrete.getValue(optionIndex));
220 break;
221 case REAL:
222 IssueReal lIssueReal = (IssueReal) lIssue;
223 int optionInd = randomnr.nextInt(lIssueReal
224 .getNumberOfDiscretizationSteps() - 1);
225 values.put(
226 lIssueReal.getNumber(),
227 new ValueReal(lIssueReal.getLowerBound()
228 + (lIssueReal.getUpperBound() - lIssueReal
229 .getLowerBound())
230 * (double) (optionInd)
231 / (double) (lIssueReal
232 .getNumberOfDiscretizationSteps())));
233 break;
234 case INTEGER:
235 IssueInteger lIssueInteger = (IssueInteger) lIssue;
236 int optionIndex2 = lIssueInteger.getLowerBound()
237 + randomnr.nextInt(lIssueInteger.getUpperBound()
238 - lIssueInteger.getLowerBound());
239 values.put(lIssueInteger.getNumber(), new ValueInteger(
240 optionIndex2));
241 break;
242 default:
243 throw new Exception("issue type " + lIssue.getType()
244 + " not supported by SamantaAgent2");
245 }
246 }
247 bid = new Bid(utilitySpace.getDomain(), values);
248 } while (getUtility(bid) < MINIMUM_BID_UTILITY);
249
250 return bid;
251 }
252
253 /**
254 * This function determines the accept probability for an offer. At t=0 it
255 * will prefer high-utility offers. As t gets closer to 1, it will accept
256 * lower utility offers with increasing probability. it will never accept
257 * offers with utility 0.
258 *
259 * @param u
260 * is the utility
261 * @param t
262 * is the time as fraction of the total available time (t=0 at
263 * start, and t=1 at end time)
264 * @return the probability of an accept at time t
265 * @throws Exception
266 * if you use wrong values for u or t.
267 *
268 */
269 double Paccept(double u, double t1) throws Exception {
270 double t = t1 * t1 * t1; // steeper increase when deadline approaches.
271 if (u < 0 || u > 1.05)
272 throw new Exception("utility " + u + " outside [0,1]");
273 // normalization may be slightly off, therefore we have a broad boundary
274 // up to 1.05
275 if (t < 0 || t > 1)
276 throw new Exception("time " + t + " outside [0,1]");
277 if (u > 1.)
278 u = 1;
279 if (t == 0.5)
280 return u;
281 return (u - 2. * u * t + 2. * (-1. + t + Math.sqrt(sq(-1. + t) + u
282 * (-1. + 2 * t))))
283 / (-1. + 2 * t);
284 }
285
286 double sq(double x) {
287 return x * x;
288 }
289}
Note: See TracBrowser for help on using the repository browser.