source: src/main/java/agents/anac/y2015/Mercury/OpponentBidHistory.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: 16.5 KB
Line 
1package agents.anac.y2015.Mercury;
2
3import java.util.ArrayList;
4import java.util.HashMap;
5import java.util.List;
6import java.util.Random;
7
8import genius.core.Bid;
9import genius.core.Domain;
10import genius.core.issue.Issue;
11import genius.core.issue.IssueDiscrete;
12import genius.core.issue.IssueInteger;
13import genius.core.issue.IssueReal;
14import genius.core.issue.Value;
15import genius.core.issue.ValueInteger;
16import genius.core.issue.ValueReal;
17import genius.core.utility.AdditiveUtilitySpace;
18
19//import negotiator.parties.AbstractNegotiationParty;
20/**
21 * Operations related with the opponent's bid history. The opponent's first 100
22 * unique bids are remembered.
23 *
24 * @author Justin
25 */
26public class OpponentBidHistory {
27
28 private ArrayList<Bid> bidHistory;
29 private ArrayList<ArrayList<Integer>> opponentBidsStatisticsForReal;
30 private ArrayList<HashMap<Value, Integer>> opponentBidsStatisticsDiscrete;
31 private ArrayList<ArrayList<Integer>> opponentBidsStatisticsForInteger;
32 private int maximumBidsStored = 100;
33 private HashMap<Bid, Integer> bidCounter = new HashMap<Bid, Integer>();
34 private Bid bid_maximum_from_opponent;// the bid with maximum utility
35 // proposed by the opponent so far.
36 public ArrayList<Object> partyOrder;
37 private ArrayList<Bid> oppMax;
38 private ArrayList<Bid> acceHistory;
39 private ArrayList<Object> acceHistoryParty;
40 private ArrayList<Bid> oppAcce;
41 private int partyNum = -1;
42 protected AdditiveUtilitySpace fUtilitySpace;
43
44 public OpponentBidHistory() {
45 this.bidHistory = new ArrayList<Bid>();
46 opponentBidsStatisticsForReal = new ArrayList<ArrayList<Integer>>();
47 opponentBidsStatisticsDiscrete = new ArrayList<HashMap<Value, Integer>>();
48 opponentBidsStatisticsForInteger = new ArrayList<ArrayList<Integer>>();
49 }
50
51 public void initiPartyRec(int num, AdditiveUtilitySpace pUtilitySpace) {
52 this.partyOrder = new ArrayList<Object>();
53 this.oppMax = new ArrayList<Bid>(); // the best opponent offer from each
54 // party
55 this.acceHistoryParty = new ArrayList<Object>();
56 this.acceHistory = new ArrayList<Bid>();
57 this.partyNum = num;
58 this.oppAcce = new ArrayList<Bid>(); // the best acceptance from each
59 // party
60
61 this.fUtilitySpace = pUtilitySpace;
62 }
63
64 public void updateOppRec(Bid oppbid, Object sender) {
65
66 if (partyOrder.size() < partyNum - 1) {
67 partyOrder.add(sender);
68 oppMax.add(oppbid);
69 } else {
70
71 try {
72 if (fUtilitySpace.getUtility(oppMax.get(partyOrder
73 .indexOf(sender))) < fUtilitySpace.getUtility(oppbid))
74 oppMax.set(partyOrder.indexOf(sender), oppbid);
75
76 } catch (Exception e) {
77 System.out.println("error in updateOppRec method"
78 + e.getMessage());
79 }
80 }
81 }
82
83 public Bid getBestOpp(Object party) {
84 // Bid bid = null;
85
86 return oppMax.get(partyOrder.indexOf(party));
87 }
88
89 public Bid getMiniBestOpp() {
90 // Bid bid = null;
91 // int temp = 0;
92 Bid bid = oppMax.get(0);
93
94 for (int i = 0; i < partyNum - 1; i++) {
95
96 try {
97 // System.out.println("test in method getMiniBestOpp"+oppMax.get(0)+","+fUtilitySpace.getUtility(oppMax.get(0)));
98 // System.out.println("test in method getMiniBestOpp"+oppMax.get(1)+","+fUtilitySpace.getUtility(oppMax.get(1)));
99
100 if (fUtilitySpace.getUtility(bid) > fUtilitySpace
101 .getUtility(oppMax.get(i)))
102 bid = oppMax.get(i);
103 } catch (Exception e) {
104 System.out.println("error in method getMiniBestOpp");
105 }
106 }
107
108 return bid;
109 }
110
111 public void updateAccRec(Bid oppbid, Object sender) {
112 acceHistory.add(oppbid);
113 acceHistoryParty.add(sender);
114 }
115
116 public Bid getLastAcce() {
117 return acceHistory.get(acceHistory.size() - 1);
118 }
119
120 public void addBid(Bid bid, AdditiveUtilitySpace utilitySpace) {
121 if (bidHistory.indexOf(bid) == -1) {
122 bidHistory.add(bid);
123 }
124 try {
125 if (bidHistory.size() == 1) {
126 this.bid_maximum_from_opponent = bidHistory.get(0);
127 } else {
128 if (utilitySpace.getUtility(bid) > utilitySpace
129 .getUtility(this.bid_maximum_from_opponent)) {
130 this.bid_maximum_from_opponent = bid;
131 }
132 }
133 } catch (Exception e) {
134 System.out.println("error in addBid method" + e.getMessage());
135 }
136 }
137
138 public Bid getBestBidInHistory() {
139 return this.bid_maximum_from_opponent;
140 }
141
142 /**
143 * initialization
144 */
145 public void initializeDataStructures(Domain domain) {
146 try {
147 List<Issue> issues = domain.getIssues();
148 for (Issue lIssue : issues) {
149 switch (lIssue.getType()) {
150 case DISCRETE:
151 IssueDiscrete lIssueDiscrete = (IssueDiscrete) lIssue;
152 HashMap<Value, Integer> discreteIssueValuesMap = new HashMap<Value, Integer>();
153 for (int j = 0; j < lIssueDiscrete.getNumberOfValues(); j++) {
154 Value v = lIssueDiscrete.getValue(j);
155 discreteIssueValuesMap.put(v, 0);
156 }
157 opponentBidsStatisticsDiscrete.add(discreteIssueValuesMap);
158 break;
159
160 case REAL:
161 IssueReal lIssueReal = (IssueReal) lIssue;
162 ArrayList<Integer> numProposalsPerValue = new ArrayList<Integer>();
163 int lNumOfPossibleValuesInThisIssue = lIssueReal
164 .getNumberOfDiscretizationSteps();
165 for (int i = 0; i < lNumOfPossibleValuesInThisIssue; i++) {
166 numProposalsPerValue.add(0);
167 }
168 opponentBidsStatisticsForReal.add(numProposalsPerValue);
169 break;
170
171 case INTEGER:
172 IssueInteger lIssueInteger = (IssueInteger) lIssue;
173 ArrayList<Integer> numOfValueProposals = new ArrayList<Integer>();
174
175 // number of possible value when issue is integer (we should
176 // add 1 in order to include all values)
177 int lNumOfPossibleValuesForThisIssue = lIssueInteger
178 .getUpperBound()
179 - lIssueInteger.getLowerBound()
180 + 1;
181 for (int i = 0; i < lNumOfPossibleValuesForThisIssue; i++) {
182 numOfValueProposals.add(0);
183 }
184 opponentBidsStatisticsForInteger.add(numOfValueProposals);
185 break;
186 }
187 }
188 } catch (Exception e) {
189 System.out.println("EXCEPTION in initializeDataAtructures");
190 }
191 }
192
193 /**
194 * This function updates the opponent's Model by calling the
195 * updateStatistics method
196 */
197 public void updateOpponentModel(Bid bidToUpdate, Object sender,
198 Domain domain, AdditiveUtilitySpace utilitySpace) {
199 this.addBid(bidToUpdate, utilitySpace);
200 // partyHistory.add(sender);
201
202 if (bidCounter.get(bidToUpdate) == null) {
203 bidCounter.put(bidToUpdate, 1);
204 } else {
205 int counter = bidCounter.get(bidToUpdate);
206 counter++;
207 bidCounter.put(bidToUpdate, counter);
208 }
209
210 if (this.bidHistory.size() <= this.maximumBidsStored) {
211 this.updateStatistics(bidToUpdate, false, domain);
212 }
213 }
214
215 /**
216 * This function updates the statistics of the bids that were received from
217 * the opponent.
218 */
219 private void updateStatistics(Bid bidToUpdate, boolean toRemove,
220 Domain domain) {
221 try {
222 List<Issue> issues = domain.getIssues();
223
224 // counters for each type of the issues
225 int realIndex = 0;
226 int discreteIndex = 0;
227 int integerIndex = 0;
228 for (Issue lIssue : issues) {
229 int issueNum = lIssue.getNumber();
230 Value v = bidToUpdate.getValue(issueNum);
231 switch (lIssue.getType()) {
232 case DISCRETE:
233 if (opponentBidsStatisticsDiscrete == null) {
234 System.out
235 .println("opponentBidsStatisticsDiscrete is NULL");
236 } else if (opponentBidsStatisticsDiscrete
237 .get(discreteIndex) != null) {
238 int counterPerValue = opponentBidsStatisticsDiscrete
239 .get(discreteIndex).get(v);
240 if (toRemove) {
241 counterPerValue--;
242 } else {
243 counterPerValue++;
244 }
245 opponentBidsStatisticsDiscrete.get(discreteIndex).put(
246 v, counterPerValue);
247 }
248 discreteIndex++;
249 break;
250
251 case REAL:
252
253 IssueReal lIssueReal = (IssueReal) lIssue;
254 int lNumOfPossibleRealValues = lIssueReal
255 .getNumberOfDiscretizationSteps();
256 double lOneStep = (lIssueReal.getUpperBound() - lIssueReal
257 .getLowerBound()) / lNumOfPossibleRealValues;
258 double first = lIssueReal.getLowerBound();
259 double last = lIssueReal.getLowerBound() + lOneStep;
260 double valueReal = ((ValueReal) v).getValue();
261 boolean found = false;
262
263 for (int i = 0; !found
264 && i < opponentBidsStatisticsForReal.get(realIndex)
265 .size(); i++) {
266 if (valueReal >= first && valueReal <= last) {
267 int countPerValue = opponentBidsStatisticsForReal
268 .get(realIndex).get(i);
269 if (toRemove) {
270 countPerValue--;
271 } else {
272 countPerValue++;
273 }
274
275 opponentBidsStatisticsForReal.get(realIndex).set(i,
276 countPerValue);
277 found = true;
278 }
279 first = last;
280 last = last + lOneStep;
281 }
282 // If no matching value was found, update the last cell
283 if (found == false) {
284 int i = opponentBidsStatisticsForReal.get(realIndex)
285 .size() - 1;
286 int countPerValue = opponentBidsStatisticsForReal.get(
287 realIndex).get(i);
288 if (toRemove) {
289 countPerValue--;
290 } else {
291 countPerValue++;
292 }
293
294 opponentBidsStatisticsForReal.get(realIndex).set(i,
295 countPerValue);
296 }
297 realIndex++;
298 break;
299
300 case INTEGER:
301
302 IssueInteger lIssueInteger = (IssueInteger) lIssue;
303 int valueInteger = ((ValueInteger) v).getValue();
304
305 int valueIndex = valueInteger
306 - lIssueInteger.getLowerBound(); // For ex.
307 // LowerBound
308 // index is 0,
309 // and the lower
310 // bound is 2,
311 // the value is
312 // 4, so the
313 // index of 4
314 // would be 2
315 // which is
316 // exactly 4-2
317 int countPerValue = opponentBidsStatisticsForInteger.get(
318 integerIndex).get(valueIndex);
319 if (toRemove) {
320 countPerValue--;
321 } else {
322 countPerValue++;
323 }
324 opponentBidsStatisticsForInteger.get(integerIndex).set(
325 valueIndex, countPerValue);
326 integerIndex++;
327 break;
328 }
329 }
330 } catch (Exception e) {
331 System.out.println("Exception in updateStatistics: "
332 + e.getMessage());
333 }
334 }
335
336 // choose a bid which is optimal for the opponent among a set of candidate
337 // bids.
338
339 public Bid ChooseBid(List<Bid> candidateBids, Domain domain) {
340
341 int upperSearchLimit = 200;// 100;
342
343 int maxIndex = -1;
344 Random ran = new Random();
345 List<Issue> issues = domain.getIssues();
346 int maxFrequency = 0;
347 int realIndex = 0;
348 int discreteIndex = 0;
349 int integerIndex = 0;
350
351 if (candidateBids.size() >= upperSearchLimit) {
352 List<Bid> bids = new ArrayList<Bid>();
353 for (int i = 0; i < upperSearchLimit; i++) {
354 int issueIndex = ran.nextInt(candidateBids.size());
355 bids.add(candidateBids.get(issueIndex));
356 }
357 candidateBids = bids;
358 }
359
360 // this whole block of code is to find the best bid
361 try {
362
363 for (int i = 0; i < candidateBids.size(); i++) {
364 int maxValue = 0;
365 realIndex = discreteIndex = integerIndex = 0;
366 for (int j = 0; j < issues.size(); j++) {
367 Value v = candidateBids.get(i).getValue(
368 issues.get(j).getNumber());
369 switch (issues.get(j).getType()) {
370 case DISCRETE:
371 if (opponentBidsStatisticsDiscrete.get(discreteIndex) != null) {
372 int counterPerValue = opponentBidsStatisticsDiscrete
373 .get(discreteIndex).get(v);
374 maxValue += counterPerValue;
375 }
376 discreteIndex++;
377 break;
378 case REAL:
379 IssueReal lIssueReal = (IssueReal) issues.get(j);
380 int lNumOfPossibleRealValues = lIssueReal
381 .getNumberOfDiscretizationSteps();
382 double lOneStep = (lIssueReal.getUpperBound() - lIssueReal
383 .getLowerBound()) / lNumOfPossibleRealValues;
384 double first = lIssueReal.getLowerBound();
385 double last = lIssueReal.getLowerBound() + lOneStep;
386 double valueReal = ((ValueReal) v).getValue();
387 boolean found = false;
388 for (int k = 0; !found
389 && k < opponentBidsStatisticsForReal.get(
390 realIndex).size(); k++) {
391 if (valueReal >= first && valueReal <= last) {
392 int counterPerValue = opponentBidsStatisticsForReal
393 .get(realIndex).get(k);
394 maxValue += counterPerValue;
395 found = true;
396 }
397 first = last;
398 last = last + lOneStep;
399 }
400 if (found == false) {
401 int k = opponentBidsStatisticsForReal
402 .get(realIndex).size() - 1;
403 int counterPerValue = opponentBidsStatisticsForReal
404 .get(realIndex).get(k);
405 maxValue += counterPerValue;
406 }
407 realIndex++;
408 break;
409
410 case INTEGER:
411 IssueInteger lIssueInteger = (IssueInteger) issues
412 .get(j);
413 int valueInteger = ((ValueInteger) v).getValue();
414 int valueIndex = valueInteger
415 - lIssueInteger.getLowerBound(); // For ex.
416 // LowerBound
417 // index is
418 // 0, and
419 // the lower
420 // bound is
421 // 2, the
422 // value is
423 // 4, so the
424 // index of
425 // 4 would
426 // be 2
427 // which is
428 // exactly
429 // 4-2
430 int counterPerValue = opponentBidsStatisticsForInteger
431 .get(integerIndex).get(valueIndex);
432 maxValue += counterPerValue;
433 integerIndex++;
434 break;
435 }
436 }
437 if (maxValue > maxFrequency) {// choose the bid with the maximum
438 // maxValue
439 maxFrequency = maxValue;
440 maxIndex = i;
441 } else if (maxValue == maxFrequency) {// random exploration
442 if (ran.nextDouble() < 0.5) {
443 maxFrequency = maxValue;
444 maxIndex = i;
445 }
446 }
447 }
448
449 } catch (Exception e) {
450 System.out.println("Exception in choosing a bid");
451 System.out.println(e.getMessage() + "---" + discreteIndex);
452 }
453 if (maxIndex == -1) {
454 return candidateBids.get(ran.nextInt(candidateBids.size()));
455 } else {
456 // here we adopt the random exploration mechanism
457 if (ran.nextDouble() < 0.95) {
458 return candidateBids.get(maxIndex);
459 } else {
460 return candidateBids.get(ran.nextInt(candidateBids.size()));
461 }
462 }
463 }
464
465 /*
466 * return the best bid from the opponent's bidding history
467 */
468
469 public Bid chooseBestFromHistory(AdditiveUtilitySpace utilitySpace) {
470 double max = -1;
471 Bid maxBid = null;
472 try {
473 for (Bid bid : bidHistory) {
474 if (max < utilitySpace.getUtility(bid)) {
475 max = utilitySpace.getUtility(bid);
476 maxBid = bid;
477 }
478 }
479 } catch (Exception e) {
480 System.out.println("ChooseBestfromhistory exception");
481 }
482 return maxBid;
483 }
484
485 // one way to predict the concession degree of the opponent
486 public double concedeDegree(AdditiveUtilitySpace utilitySpace) {
487 int numOfBids = bidHistory.size();
488 HashMap<Bid, Integer> bidCounter = new HashMap<Bid, Integer>();
489 try {
490 for (int i = 0; i < numOfBids; i++) {
491
492 if (bidCounter.get(bidHistory.get(i)) == null) {
493 bidCounter.put(bidHistory.get(i), 1);
494 } else {
495 int counter = bidCounter.get(bidHistory.get(i));
496 counter++;
497 bidCounter.put(bidHistory.get(i), counter);
498 }
499 }
500 } catch (Exception e) {
501 System.out.println("ChooseBestfromhistory exception");
502 }
503 // System.out.println("the opponent's toughness degree is " +
504 // bidCounter.size() + " divided by " +
505 // utilitySpace.getDomain().getNumberOfPossibleBids());
506 return ((double) bidCounter.size() / utilitySpace.getDomain()
507 .getNumberOfPossibleBids());
508 }
509
510 public int getSize() {
511 int numOfBids = bidHistory.size();
512 HashMap<Bid, Integer> bidCounter = new HashMap<Bid, Integer>();
513 try {
514 for (int i = 0; i < numOfBids; i++) {
515
516 if (bidCounter.get(bidHistory.get(i)) == null) {
517 bidCounter.put(bidHistory.get(i), 1);
518 } else {
519 int counter = bidCounter.get(bidHistory.get(i));
520 counter++;
521 bidCounter.put(bidHistory.get(i), counter);
522 }
523 }
524 } catch (Exception e) {
525 System.out.println("getSize exception");
526 }
527 return bidCounter.size();
528 }
529
530 // Another way to predict the opponent's concession degree
531 public double getConcessionDegree() {
532 int numOfBids = bidHistory.size();
533 double numOfDistinctBid = 0;
534 int historyLength = 10;
535 double concessionDegree = 0;
536 // HashMap<Bid, Integer> bidCounter = new HashMap<Bid, Integer>();
537 if (numOfBids - historyLength > 0) {
538 try {
539 for (int j = numOfBids - historyLength; j < numOfBids; j++) {
540 if (bidCounter.get(bidHistory.get(j)) == 1) {
541 numOfDistinctBid++;
542 }
543 }
544 concessionDegree = Math
545 .pow(numOfDistinctBid / historyLength, 2);
546 } catch (Exception e) {
547 System.out.println("getConcessionDegree exception");
548 }
549 } else {
550 numOfDistinctBid = this.getSize();
551 concessionDegree = Math.pow(numOfDistinctBid / historyLength, 2);
552 }
553 // System.out.println("the history length is" + bidHistory.size() +
554 // "concessiondegree is " + concessionDegree);
555 return concessionDegree;
556 }
557
558 public Bid getLastOppBid() {
559 return bidHistory.get(bidHistory.size() - 1);
560 }
561}
Note: See TracBrowser for help on using the repository browser.