source: src/main/java/agents/anac/y2010/Nozomi/Nozomi.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: 32.8 KB
Line 
1package agents.anac.y2010.Nozomi;
2
3import java.util.HashMap;
4import java.util.List;
5import java.util.Random;
6
7import genius.core.Agent;
8import genius.core.Bid;
9import genius.core.SupportedNegotiationSetting;
10import genius.core.actions.Accept;
11import genius.core.actions.Action;
12import genius.core.actions.ActionWithBid;
13import genius.core.actions.Offer;
14import genius.core.issue.ISSUETYPE;
15import genius.core.issue.Issue;
16import genius.core.issue.IssueDiscrete;
17import genius.core.issue.IssueInteger;
18import genius.core.issue.IssueReal;
19import genius.core.issue.Value;
20import genius.core.issue.ValueDiscrete;
21import genius.core.issue.ValueInteger;
22import genius.core.issue.ValueReal;
23import genius.core.utility.AdditiveUtilitySpace;
24import genius.core.utility.Evaluator;
25import genius.core.utility.EvaluatorDiscrete;
26
27/**
28 * ANAC2010 competitor Nozomi.
29 */
30public class Nozomi extends Agent {
31 private Bid maxUtilityBid = null;
32 private double maxUtility = 0.0;
33 private Bid prevBid = null;
34 private Bid restoreBid = null;
35 private double minGap = 0.0;
36 private Action actionOfPartner = null;
37 private Bid prevPartnerBid = null;
38 private Bid maxUtilityPartnerBid = null;
39 private double maxUtilityOfPartnerBid = 0.0;
40 private double maxCompromiseUtility = 1.0;
41 private boolean compromise = false;
42 private boolean updateMaxPartnerUtility = false;
43 private int continuousCompromiseBid = 0;
44 private int continuousPartnerCompromiseBid = 0;
45 private int continuousKeep = 0;
46 private int measureT = 1;
47 private int bidNumber = 0;
48 private double prevAverageUtility = 0.0;
49 private double averageUtility = 0.0;
50 private double averagePartnerUtility = 0.0;
51 private double prevAveragePartnerUtility = 0.0;
52 private static double COMPROMISE_PROBABILITY = 0.70;
53 private static double KEEP_PROBABILITY = 0.15;
54 private final boolean TEST_EQUIVALENCE = false;
55 private Random random100;
56 private Random random200;
57
58 private static enum BidType {
59 COMPROMISE, KEEP, APPROACH, RESTORE, RANDOM
60 };
61
62 /**
63 * init is called when a next session starts with the same opponent.
64 */
65
66 @Override
67 public void init() {
68 try {
69 maxUtilityBid = utilitySpace.getMaxUtilityBid();
70 maxUtility = utilitySpace.getUtility(maxUtilityBid);
71 prevAverageUtility = maxUtility;
72 maxCompromiseUtility = maxUtility * 0.95;
73 restoreBid = maxUtilityBid;
74 minGap = utilitySpace.getDomain().getIssues().size();
75
76 if (TEST_EQUIVALENCE) {
77 random100 = new Random(100);
78 random200 = new Random(200);
79 } else {
80 random100 = new Random();
81 random200 = new Random();
82 }
83 } catch (Exception e) {
84 e.printStackTrace();
85 }
86 }
87
88 @Override
89 public String getVersion() {
90 return "1.0";
91 }
92
93 @Override
94 public String getName() {
95 return "Nozomi";
96 }
97
98 @Override
99 public void ReceiveMessage(Action opponentAction) {
100 actionOfPartner = opponentAction;
101 }
102
103 @Override
104 public Action chooseAction() {
105 Action action = null;
106
107 try {
108 if (actionOfPartner == null) {
109 action = new Offer(getAgentID(), maxUtilityBid);
110 prevBid = maxUtilityBid;
111 } else if (actionOfPartner instanceof Offer) {
112 Bid partnerBid = ((Offer) actionOfPartner).getBid();
113
114 if (isAccept(partnerBid)) {
115 action = new Accept(getAgentID(), partnerBid);
116 } else {
117 action = chooseBidAction(partnerBid);
118 }
119 prevPartnerBid = partnerBid;
120 }
121 } catch (Exception e) {
122 action = new Accept(getAgentID(),
123 ((ActionWithBid) actionOfPartner).getBid());
124 }
125 return action;
126 }
127
128 private Action chooseBidAction(Bid partnerBid) {
129 Action action = null;
130
131 try {
132 if (prevPartnerBid == null) {
133 maxUtilityPartnerBid = partnerBid;
134 maxUtilityOfPartnerBid = utilitySpace.getUtility(partnerBid);
135 action = new Offer(getAgentID(), maxUtilityBid);
136
137 prevBid = maxUtilityBid;
138 } else {
139 bidNumber++;
140 double prevPartnerUtility = utilitySpace
141 .getUtility(prevPartnerBid);
142 double partnerUtility = utilitySpace.getUtility(partnerBid);
143
144 averagePartnerUtility += partnerUtility;
145 if (partnerUtility < prevPartnerUtility) {
146 if (continuousPartnerCompromiseBid < 0)
147 continuousPartnerCompromiseBid = 0;
148 continuousPartnerCompromiseBid++;
149 } else if (partnerUtility > prevPartnerUtility) {
150 if (continuousPartnerCompromiseBid > 0)
151 continuousPartnerCompromiseBid = 0;
152 continuousPartnerCompromiseBid--;
153 } else {
154 continuousPartnerCompromiseBid = 0;
155 }
156
157 double time = timeline.getTime() * 100;
158
159 if (maxUtilityOfPartnerBid > maxCompromiseUtility) {
160 maxCompromiseUtility = maxUtilityOfPartnerBid;
161 }
162
163 if (time > 90 && maxCompromiseUtility
164 - maxUtilityOfPartnerBid < 0.1) {
165 maxCompromiseUtility = (maxCompromiseUtility * 7.0
166 + maxUtilityOfPartnerBid * 3.0) / 10.0;
167 }
168
169 if (maxCompromiseUtility > maxUtility * 0.95) {
170 maxCompromiseUtility = maxUtility * 0.95;
171 }
172
173 Bid nextBid = prevBid;
174 BidType bidType = chooseBidType(partnerBid);
175
176 switch (bidType) {
177 case RESTORE:
178 nextBid = restoreBid;
179 break;
180 case APPROACH:
181 nextBid = getApproachBid(partnerBid);
182
183 if (utilitySpace.getUtility(nextBid) < maxCompromiseUtility
184 || utilitySpace
185 .getUtility(nextBid) > maxCompromiseUtility
186 * 105 / 95) {
187 nextBid = getBetweenBid(nextBid, partnerBid,
188 maxCompromiseUtility,
189 maxCompromiseUtility * 105 / 95);
190 }
191 break;
192 case COMPROMISE:
193 nextBid = getCompromiseBid(partnerBid);
194
195 if (utilitySpace
196 .getUtility(nextBid) < maxCompromiseUtility) {
197 nextBid = getBetweenBid(nextBid, partnerBid,
198 maxCompromiseUtility,
199 maxCompromiseUtility * 105 / 95);
200 }
201
202 if (continuousCompromiseBid < 0)
203 continuousCompromiseBid = 0;
204 continuousCompromiseBid++;
205 break;
206 case KEEP:
207 nextBid = prevBid;
208 continuousCompromiseBid /= 2;
209 break;
210 }
211
212 if (utilitySpace.getUtility(
213 nextBid) <= utilitySpace.getUtility(prevBid) / 2.0) {
214 nextBid = getApproachBid(partnerBid);
215
216 if (utilitySpace.getUtility(nextBid) < maxCompromiseUtility
217 || utilitySpace
218 .getUtility(nextBid) > maxCompromiseUtility
219 * 105 / 95) {
220 nextBid = getBetweenBid(nextBid, partnerBid,
221 maxCompromiseUtility,
222 maxCompromiseUtility * 105 / 95);
223 }
224 }
225
226 if (((utilitySpace.getUtility(nextBid) < maxCompromiseUtility
227 || utilitySpace.getUtility(
228 nextBid) > maxCompromiseUtility * 105 / 95)
229 && continuousKeep < 20)
230 || utilitySpace.getUtility(
231 nextBid) <= utilitySpace.getUtility(prevBid)
232 / 2.0
233 || utilitySpace
234 .getUtility(nextBid) < maxUtilityOfPartnerBid) {
235
236 nextBid = restoreBid;
237 }
238
239 averageUtility += utilitySpace.getUtility(nextBid);
240
241 if (continuousKeep <= 0) {
242 updateRestoreBid(nextBid);
243 }
244
245 if (time > measureT * 3.0) {
246 checkCompromise(time);
247 averageUtility = 0.0;
248 averagePartnerUtility = 0.0;
249 bidNumber = 1;
250 measureT++;
251 }
252
253 if (utilitySpace.getUtility(nextBid) == utilitySpace
254 .getUtility(prevBid)) {
255 continuousKeep++;
256 } else {
257 continuousKeep = 0;
258 }
259
260 if (continuousKeep > 30 && time > 90.0) {
261 maxCompromiseUtility *= 0.99;
262 continuousKeep = 0;
263 }
264
265 prevBid = nextBid;
266 action = new Offer(getAgentID(), nextBid);
267 }
268 } catch (Exception e) {
269 action = new Accept(getAgentID(),
270 ((ActionWithBid) actionOfPartner).getBid());
271 }
272 return action;
273 }
274
275 private void checkCompromise(double time) {
276 averageUtility /= bidNumber;
277 averagePartnerUtility /= bidNumber;
278
279 double diff = prevAverageUtility - averageUtility;
280 double partnerDiff = averagePartnerUtility - prevAveragePartnerUtility;
281
282 if (compromise) {
283 double gap = Math.abs(averageUtility - averagePartnerUtility);
284 if (partnerDiff < diff * 0.90
285 || gap > Math.pow(1.0 - time / 100, 2.0) * 0.90) {
286 double p1 = maxCompromiseUtility, p2 = maxCompromiseUtility;
287 for (int attenuation = 95; attenuation <= 100; attenuation++) {
288 if (maxCompromiseUtility * attenuation
289 / 100 > maxUtilityOfPartnerBid) {
290 p1 = maxCompromiseUtility * attenuation / 100;
291 break;
292 }
293 }
294
295 for (int attenuation = 10; attenuation < 1000; attenuation++) {
296 if (maxCompromiseUtility
297 - gap / attenuation > maxUtilityOfPartnerBid) {
298 p2 = maxCompromiseUtility - gap / attenuation;
299 break;
300 }
301 }
302
303 maxCompromiseUtility = (p1 + p2) / 2;
304
305 prevAverageUtility = averageUtility;
306 compromise = false;
307 }
308 } else {
309 if (partnerDiff > diff * 0.90
310 || (time > 50 && updateMaxPartnerUtility)) {
311 prevAveragePartnerUtility = averagePartnerUtility;
312 compromise = true;
313 }
314 }
315 updateMaxPartnerUtility = false;
316 }
317
318 private BidType chooseBidType(Bid partnerBid) {
319 BidType bidType = null;
320
321 try {
322 double time = timeline.getTime();
323
324 double prevUtility = utilitySpace.getUtility(prevBid);
325 double partnerUtility = utilitySpace.getUtility(partnerBid);
326 double gap = Math.abs(prevUtility - partnerUtility);
327
328 if (gap < 0.05)
329 return BidType.APPROACH;
330
331 gap = Math.abs(prevAverageUtility - prevAverageUtility);
332 if (gap < 0.10 && time > 0.80)
333 return BidType.APPROACH;
334
335 if (random100.nextInt(20) <= 0)
336 return BidType.RESTORE;
337
338 int approachBorder = 5;
339 if (time > 0.9) {
340 approachBorder = (int) Math.round((time * 100) / 10);
341 }
342 if (random100.nextInt(20) <= approachBorder)
343 return BidType.RESTORE;
344
345 if (prevUtility > maxCompromiseUtility * 105 / 95) {
346 return BidType.COMPROMISE;
347 }
348 if (continuousKeep > 20 && time > 0.60
349 && random100.nextDouble() > 0.60)
350 return BidType.APPROACH;
351
352 } catch (Exception e) {
353 bidType = BidType.RESTORE;
354 }
355
356 double rnd = random100.nextDouble();
357 double compromiseProbability = getCompromiseProbability();
358
359 if (rnd < compromiseProbability) {
360 bidType = BidType.COMPROMISE;
361 } else if (rnd < getKeepProbability(compromiseProbability)
362 + compromiseProbability) {
363 bidType = BidType.KEEP;
364 }
365
366 if (bidType == null)
367 bidType = bidType.RESTORE;
368 return bidType;
369 }
370
371 private double getCompromiseProbability() {
372 double compromiseProbabilty = 0.0;
373
374 try {
375 double prevUtility = utilitySpace.getUtility(prevBid);
376 double prevUtilityOfPartnerBid = utilitySpace
377 .getUtility(prevPartnerBid);
378 // Below Values are less and less, more and more compromised.
379 double compromiseDegree = prevUtility / maxUtility;
380
381 double compromisePartnerDegree = 1.0
382 - prevUtilityOfPartnerBid / maxUtility;
383
384 double continuous = ((double) continuousCompromiseBid
385 + (double) Math.abs(continuousPartnerCompromiseBid) + 0.001)
386 / 2.0;
387 double ratioUtilityToMaxUtility = prevUtility / (maxUtility * 0.9);
388
389 compromiseProbabilty = (compromiseDegree + compromisePartnerDegree)
390 / 2.0;
391
392 compromiseProbabilty /= 1.0 + continuous / 8.0;
393 compromiseProbabilty *= ratioUtilityToMaxUtility;
394 } catch (Exception e) {
395 compromiseProbabilty = COMPROMISE_PROBABILITY;
396 }
397
398 return compromiseProbabilty;
399 }
400
401 private double getKeepProbability(double compromiseProbability) {
402 double keepProbability = 1.0 - compromiseProbability;
403
404 try {
405 double time = timeline.getTime();
406 double prevUtility = utilitySpace.getUtility(prevBid);
407 double prevUtilityOfPartnerBid = utilitySpace
408 .getUtility(prevPartnerBid);
409 double ratioUtilityToMaxUtility = prevUtility / (maxUtility * 0.8);
410
411 if (prevUtility > prevUtilityOfPartnerBid) {
412 keepProbability *= (prevUtility - prevUtilityOfPartnerBid)
413 / maxUtility;
414 keepProbability *= time;
415 keepProbability *= 1.0
416 + Math.abs(continuousCompromiseBid) / 4.0;
417 keepProbability *= ratioUtilityToMaxUtility;
418 } else {
419 keepProbability = 0.0;
420 }
421 } catch (Exception e) {
422 keepProbability = KEEP_PROBABILITY;
423 }
424
425 return keepProbability;
426 }
427
428 private Bid getCompromiseBid(Bid partnerBid) {
429 Bid compromiseBid = prevBid;
430 try {
431
432 double compromiseUtility = 0.0;
433 double prevUtility = utilitySpace.getUtility(prevBid);
434 double basicUtility = prevUtility;
435 double gap = Math
436 .abs(prevUtility - utilitySpace.getUtility(partnerBid));
437 HashMap<Integer, Value> values = new HashMap<Integer, Value>();
438 List<Issue> issues = utilitySpace.getDomain().getIssues();
439
440 for (Issue issue : issues) {
441 values.put(issue.getNumber(),
442 prevBid.getValue(issue.getNumber()));
443 }
444
445 Integer changeIssueID = -1;
446 for (Issue compromiseIssue : issues) {
447 Integer compromiseIssueID = compromiseIssue.getNumber();
448
449 if ((!prevPartnerBid.getValue(compromiseIssueID)
450 .equals(partnerBid.getValue(compromiseIssueID))
451 && gap > 0.05 && continuousKeep < 20)
452 || prevBid.getValue(compromiseIssueID)
453 .equals(partnerBid.getValue(compromiseIssueID))
454 || compromiseIssueID == changeIssueID) {
455 continue;
456 }
457
458 HashMap<Integer, Value> candidateValues = new HashMap<Integer, Value>(
459 values);
460 candidateValues.remove(compromiseIssueID);
461 candidateValues.put(compromiseIssueID,
462 getCompromiseValue(compromiseIssue,
463 prevBid.getValue(compromiseIssueID),
464 partnerBid.getValue(compromiseIssueID)));
465 Bid candidateBid = new Bid(utilitySpace.getDomain(),
466 candidateValues);
467 double candidateUtility = utilitySpace.getUtility(candidateBid);
468
469 if (candidateUtility > compromiseUtility
470 && candidateUtility < basicUtility) {
471
472 compromiseUtility = candidateUtility;
473 compromiseBid = candidateBid;
474 changeIssueID = compromiseIssueID;
475 }
476 }
477
478 } catch (Exception e) {
479 e.printStackTrace();
480 compromiseBid = restoreBid; // best guess if things go wrong.
481 }
482 try {
483 } catch (Exception e) {
484 e.printStackTrace();
485 }
486 return compromiseBid;
487 }
488
489 private Value getCompromiseValue(Issue issue, Value val, Value partnerVal) {
490 Value compromiseVal = null;
491 Evaluator eval = ((AdditiveUtilitySpace) utilitySpace)
492 .getEvaluator(issue.getNumber());
493
494 switch (issue.getType()) {
495 case DISCRETE:
496 EvaluatorDiscrete evalDiscrete = (EvaluatorDiscrete) eval;
497 compromiseVal = val;
498 Integer evaluation = evalDiscrete.getValue((ValueDiscrete) val);
499 IssueDiscrete issueDiscrete = (IssueDiscrete) issue;
500 Integer compromiseEvaluation = 0;
501 for (int i = 0; i < issueDiscrete.getNumberOfValues(); i++) {
502 ValueDiscrete candidateVal = issueDiscrete.getValue(i);
503 Integer candidateEvaluation = evalDiscrete
504 .getValue(candidateVal);
505 if (candidateEvaluation >= compromiseEvaluation
506 && candidateEvaluation < evaluation) {
507 compromiseVal = candidateVal;
508 compromiseEvaluation = candidateEvaluation;
509 }
510 }
511 break;
512 case INTEGER:
513 ValueInteger valInt = (ValueInteger) val;
514 int compromiseInt = valInt.getValue();
515 ValueInteger partnerValInt = (ValueInteger) partnerVal;
516 if (compromiseInt > partnerValInt.getValue()) {
517 compromiseInt--;
518 } else {
519 compromiseInt++;
520 }
521 compromiseVal = new ValueInteger(compromiseInt);
522 break;
523 case REAL:
524 ValueReal valReal = (ValueReal) val;
525 double compromiseReal = valReal.getValue();
526 ValueReal partnerValReal = (ValueReal) partnerVal;
527 compromiseReal += new Random().nextDouble()
528 * (partnerValReal.getValue() - compromiseReal) / 10;
529 compromiseVal = new ValueReal(compromiseReal);
530 break;
531 default:
532 compromiseVal = val;
533 break;
534 }
535 return compromiseVal;
536 }
537
538 private Bid getBetweenBid(Bid basicBid, Bid partnerBid, double minUtility,
539 double maxUtility) {
540 Bid betweenBid = basicBid;
541 try {
542 List<Issue> issues = utilitySpace.getDomain().getIssues();
543 HashMap<Integer, Value> values = new HashMap<Integer, Value>();
544
545 for (Issue issue : issues) {
546 values.put(issue.getNumber(),
547 basicBid.getValue(issue.getNumber()));
548 }
549
550 double utility = utilitySpace.getUtility(basicBid);
551 for (int i = 0; i < 1000; i++) {
552 Issue issue = issues.get(random200.nextInt(issues.size()));
553 int issueID = issue.getNumber();
554
555 if (prevBid.getValue(issueID)
556 .equals(partnerBid.getValue(issueID))) {
557 continue;
558 }
559
560 Value value = values.get(issueID);
561 values.remove(issueID);
562 if (utility > maxUtility) {
563 values.put(issueID, getLowerValue(issue, value, values));
564 } else {
565 values.put(issueID, getHigherValue(issue, value, values));
566 }
567
568 Bid candidateBid = new Bid(utilitySpace.getDomain(), values);
569 utility = utilitySpace.getUtility(candidateBid);
570 if (utility > minUtility && utility < maxUtility) {
571 betweenBid = candidateBid;
572 break;
573 }
574 }
575 } catch (Exception e) {
576 betweenBid = restoreBid;
577 }
578 return betweenBid;
579 }
580
581 private Value getHigherValue(Issue issue, Value value,
582 HashMap<Integer, Value> values) {
583 Value higher = null;
584 Evaluator eval = ((AdditiveUtilitySpace) utilitySpace)
585 .getEvaluator(issue.getNumber());
586
587 switch (issue.getType()) {
588 case DISCRETE:
589 EvaluatorDiscrete evalDiscrete = (EvaluatorDiscrete) eval;
590
591 Integer evaluation = evalDiscrete.getValue((ValueDiscrete) value);
592 IssueDiscrete issueDiscrete = (IssueDiscrete) issue;
593 higher = evalDiscrete.getMaxValue();
594 Integer highEvaluation = evalDiscrete
595 .getValue((ValueDiscrete) higher);
596 for (int i = 0; i < issueDiscrete.getNumberOfValues(); i++) {
597 ValueDiscrete candidateVal = issueDiscrete.getValue(i);
598 Integer candidateEvaluation = evalDiscrete
599 .getValue(candidateVal);
600 if (candidateEvaluation < highEvaluation
601 && candidateEvaluation > evaluation) {
602 higher = candidateVal;
603 highEvaluation = candidateEvaluation;
604 }
605 }
606 break;
607 case INTEGER:
608 IssueInteger issueInt = (IssueInteger) issue;
609 ValueInteger valInt = (ValueInteger) value;
610 try {
611 Bid bid = new Bid(utilitySpace.getDomain(), values);
612 values.remove(issueInt.getNumber());
613 values.put(issueInt.getNumber(),
614 new ValueInteger(valInt.getValue() - 1));
615 Bid candidateBid = new Bid(utilitySpace.getDomain(), values);
616 if (utilitySpace.getUtility(candidateBid) > utilitySpace
617 .getUtility(bid)) {
618 higher = new ValueInteger(valInt.getValue() - 1);
619 } else {
620 higher = new ValueInteger(valInt.getValue() + 1);
621 }
622 } catch (Exception e) {
623 higher = valInt;
624 }
625 break;
626 case REAL:
627 IssueReal issueReal = (IssueReal) issue;
628 ValueReal valReal = (ValueReal) value;
629 try {
630 Bid bid = new Bid(utilitySpace.getDomain(), values);
631 values.remove(issueReal.getNumber());
632 values.put(issueReal.getNumber(), new ValueReal(valReal
633 .getValue()
634 - (valReal.getValue() - issueReal.getLowerBound())
635 / 10));
636 Bid candidateBid = new Bid(utilitySpace.getDomain(), values);
637 if (utilitySpace.getUtility(candidateBid) > utilitySpace
638 .getUtility(bid)) {
639 higher = new ValueReal(
640 valReal.getValue()
641 - new Random().nextDouble()
642 * (valReal.getValue()
643 - issueReal.getLowerBound())
644 / 10);
645 } else {
646 higher = new ValueReal(valReal.getValue() + new Random()
647 .nextDouble()
648 * (issueReal.getUpperBound() - valReal.getValue())
649 / 10);
650 }
651 } catch (Exception e) {
652 higher = valReal;
653 }
654 break;
655 default:
656 higher = value;
657 break;
658 }
659
660 return higher;
661 }
662
663 private Value getLowerValue(Issue issue, Value value,
664 HashMap<Integer, Value> values) {
665 Value lower = null;
666 Evaluator eval = ((AdditiveUtilitySpace) utilitySpace)
667 .getEvaluator(issue.getNumber());
668
669 switch (issue.getType()) {
670 case DISCRETE:
671 EvaluatorDiscrete evalDiscrete = (EvaluatorDiscrete) eval;
672
673 Integer evaluation = evalDiscrete.getValue((ValueDiscrete) value);
674 IssueDiscrete issueDiscrete = (IssueDiscrete) issue;
675 lower = evalDiscrete.getMinValue();
676 Integer lowEvaluation = evalDiscrete
677 .getValue((ValueDiscrete) lower);
678 for (int i = 0; i < issueDiscrete.getNumberOfValues(); i++) {
679 ValueDiscrete candidateVal = issueDiscrete.getValue(i);
680 Integer candidateEvaluation = evalDiscrete
681 .getValue(candidateVal);
682 if (candidateEvaluation > lowEvaluation
683 && candidateEvaluation < evaluation) {
684 lower = candidateVal;
685 lowEvaluation = candidateEvaluation;
686 }
687 }
688 break;
689 case INTEGER:
690 IssueInteger issueInt = (IssueInteger) issue;
691 ValueInteger valInt = (ValueInteger) value;
692 try {
693 Bid bid = new Bid(utilitySpace.getDomain(), values);
694 values.remove(issueInt.getNumber());
695 values.put(issueInt.getNumber(),
696 new ValueInteger(valInt.getValue() - 1));
697 Bid candidateBid = new Bid(utilitySpace.getDomain(), values);
698 if (utilitySpace.getUtility(candidateBid) < utilitySpace
699 .getUtility(bid)) {
700 lower = new ValueInteger(valInt.getValue() - 1);
701 } else {
702 lower = new ValueInteger(valInt.getValue() + 1);
703 }
704 } catch (Exception e) {
705 lower = valInt;
706 }
707 break;
708 case REAL:
709 IssueReal issueReal = (IssueReal) issue;
710 ValueReal valReal = (ValueReal) value;
711 try {
712 Bid bid = new Bid(utilitySpace.getDomain(), values);
713 values.remove(issueReal.getNumber());
714 values.put(issueReal.getNumber(), new ValueReal(valReal
715 .getValue()
716 - (valReal.getValue() - issueReal.getLowerBound())
717 / 10));
718 Bid candidateBid = new Bid(utilitySpace.getDomain(), values);
719 if (utilitySpace.getUtility(candidateBid) < utilitySpace
720 .getUtility(bid)) {
721 lower = new ValueReal(
722 valReal.getValue()
723 - new Random().nextDouble()
724 * (valReal.getValue()
725 - issueReal.getLowerBound())
726 / 10);
727 } else {
728 lower = new ValueReal(valReal.getValue() + new Random()
729 .nextDouble()
730 * (issueReal.getUpperBound() - valReal.getValue())
731 / 10);
732 }
733 } catch (Exception e) {
734 lower = valReal;
735 }
736 break;
737 default:
738 lower = value;
739 break;
740 }
741 return lower;
742 }
743
744 private Bid getApproachBid(Bid partnerBid) {
745 Bid approachBid = prevBid;
746 try {
747 HashMap<Integer, Value> values = new HashMap<Integer, Value>();
748 HashMap<Integer, Value> approachValues = new HashMap<Integer, Value>();
749 List<Issue> issues = utilitySpace.getDomain().getIssues();
750
751 for (Issue issue : issues) {
752 values.put(issue.getNumber(),
753 prevBid.getValue(issue.getNumber()));
754 }
755 approachValues = values;
756
757 double candidateUtility = 0.0;
758 for (Issue issue : issues) {
759 int issueID = issue.getNumber();
760
761 if (issue.getType() == ISSUETYPE.REAL) {
762 IssueReal issueReal = (IssueReal) issue;
763 ValueReal valueReal = (ValueReal) prevBid.getValue(issueID);
764 ValueReal partnerValueReal = (ValueReal) partnerBid
765 .getValue(issueID);
766 ValueReal prevPartnerValueReal = (ValueReal) prevPartnerBid
767 .getValue(issueID);
768 double gap = Math.abs(
769 valueReal.getValue() - partnerValueReal.getValue());
770 double gapPartnerValue = Math
771 .abs(partnerValueReal.getValue()
772 - prevPartnerValueReal.getValue());
773 if (gap < (issueReal.getUpperBound()
774 - issueReal.getLowerBound()) / 100
775 || !(gapPartnerValue < (issueReal.getUpperBound()
776 - issueReal.getLowerBound()) / 100)) {
777 continue;
778 }
779 }
780
781 if (prevBid.getValue(issueID)
782 .equals(partnerBid.getValue(issueID))) {
783 continue;
784 }
785
786 HashMap<Integer, Value> candidateValues = new HashMap<Integer, Value>(
787 values);
788
789 candidateValues.remove(issueID);
790 candidateValues.put(issueID,
791 getApproachValue(issue, prevBid.getValue(issueID),
792 partnerBid.getValue(issueID)));
793 Bid candidateBid = new Bid(utilitySpace.getDomain(),
794 candidateValues);
795 if (utilitySpace.getUtility(candidateBid) > candidateUtility) {
796 candidateUtility = utilitySpace.getUtility(candidateBid);
797 approachBid = candidateBid;
798 approachValues = candidateValues;
799 }
800 }
801
802 while (true) {
803 candidateUtility = 0.0;
804 HashMap<Integer, Value> candidateValues = new HashMap<Integer, Value>(
805 approachValues);
806 for (Issue issue : issues) {
807 HashMap<Integer, Value> tempValues = new HashMap<Integer, Value>(
808 approachValues);
809
810 int issueID = issue.getNumber();
811
812 if (issue.getType() == ISSUETYPE.REAL) {
813 IssueReal issueReal = (IssueReal) issue;
814 ValueReal valueReal = (ValueReal) prevBid
815 .getValue(issueID);
816 ValueReal partnerValueReal = (ValueReal) partnerBid
817 .getValue(issueID);
818 double gap = Math.abs(valueReal.getValue()
819 - partnerValueReal.getValue());
820 if (gap < (issueReal.getUpperBound()
821 - issueReal.getLowerBound()) / 100) {
822 continue;
823 }
824 }
825
826 if (prevBid.getValue(issueID)
827 .equals(partnerBid.getValue(issueID))) {
828 continue;
829 }
830
831 tempValues.remove(issueID);
832 tempValues.put(issueID,
833 getApproachValue(issue, prevBid.getValue(issueID),
834 partnerBid.getValue(issueID)));
835
836 Bid tempBid = new Bid(utilitySpace.getDomain(), tempValues);
837 if (utilitySpace.getUtility(tempBid) > candidateUtility) {
838 candidateValues = tempValues;
839 candidateUtility = utilitySpace.getUtility(tempBid);
840 }
841 }
842 if (candidateUtility >= utilitySpace.getUtility(approachBid)
843 && !candidateValues.equals(approachValues)) {
844 Bid candidateBid = new Bid(utilitySpace.getDomain(),
845 candidateValues);
846 approachBid = candidateBid;
847 approachValues = candidateValues;
848 } else {
849 break;
850 }
851 }
852 } catch (Exception e) {
853 approachBid = restoreBid; // best guess if things go wrong.
854 }
855 return approachBid;
856 }
857
858 private Value getApproachValue(Issue issue, Value myVal, Value partnerVal) {
859 Value approachVal = null;
860
861 switch (issue.getType()) {
862 case DISCRETE:
863 IssueDiscrete issueDiscrete = (IssueDiscrete) issue;
864
865 boolean checkMyVal = false;
866 boolean checkPartnerVal = false;
867 for (Value value : issueDiscrete.getValues()) {
868 if (checkMyVal) {
869 approachVal = value;
870 break;
871 }
872
873 if (myVal.equals(value)) {
874 if (checkPartnerVal) {
875 break;
876 } else {
877 checkMyVal = true;
878 }
879 }
880
881 if (partnerVal.equals(value)) {
882 if (checkMyVal) {
883 approachVal = value;
884 break;
885 } else {
886 checkPartnerVal = true;
887 }
888 }
889
890 approachVal = value;
891 }
892 break;
893 case INTEGER:
894 ValueInteger valInt = (ValueInteger) myVal;
895 int approachInt = valInt.getValue();
896 ValueInteger partnerValInt = (ValueInteger) partnerVal;
897 if (approachInt > partnerValInt.getValue()) {
898 approachInt--;
899 } else {
900 approachInt++;
901 }
902 approachVal = new ValueInteger(approachInt);
903 break;
904 case REAL:
905 ValueReal valReal = (ValueReal) myVal;
906 double approachReal = valReal.getValue();
907 ValueReal partnerValReal = (ValueReal) partnerVal;
908 approachReal += new Random().nextDouble()
909 * (partnerValReal.getValue() - approachReal) / 10;
910 approachVal = new ValueReal(approachReal);
911 break;
912 default:
913 approachVal = myVal;
914 break;
915 }
916 return approachVal;
917 }
918
919 private void updateRestoreBid(Bid nextBid) {
920 List<Issue> issues = utilitySpace.getDomain().getIssues();
921
922 try {
923 } catch (Exception e) {
924 e.printStackTrace();
925 }
926 double evalGap = 0.0;
927 for (Issue issue : issues) {
928 int issueID = issue.getNumber();
929 Evaluator eval = ((AdditiveUtilitySpace) utilitySpace)
930 .getEvaluator(issueID);
931
932 try {
933 evalGap += Math.abs(eval.getEvaluation(
934 ((AdditiveUtilitySpace) utilitySpace), nextBid, issueID)
935 - eval.getEvaluation(
936 ((AdditiveUtilitySpace) utilitySpace),
937 maxUtilityPartnerBid, issueID));
938
939 } catch (Exception e) {
940 evalGap += 1.0;
941 }
942 }
943 if (evalGap < minGap) {
944 restoreBid = nextBid;
945 minGap = evalGap;
946 } else if (evalGap == minGap) {
947 try {
948 if (utilitySpace.getUtility(nextBid) > utilitySpace
949 .getUtility(restoreBid)) {
950 restoreBid = nextBid;
951 }
952 } catch (Exception e) {
953 e.printStackTrace();
954 }
955 }
956 }
957
958 private boolean isAccept(Bid partnerBid) {
959 boolean accept = false;
960 try {
961 double prevUtility = utilitySpace.getUtility(prevBid);
962 double offeredUtil = utilitySpace.getUtility(partnerBid);
963 double time = timeline.getTime();
964
965 if (offeredUtil > maxUtilityOfPartnerBid) {
966 maxUtilityPartnerBid = partnerBid;
967 maxUtilityOfPartnerBid = offeredUtil;
968 updateMaxPartnerUtility = true;
969 }
970
971 if (offeredUtil > maxUtility * 0.95 || offeredUtil >= prevUtility) {
972 accept = true;
973 } else {
974 List<Issue> issues = utilitySpace.getDomain().getIssues();
975
976 double evalGap = 0.0;
977 for (Issue issue : issues) {
978
979 int issueID = issue.getNumber();
980
981 switch (issue.getType()) {
982 case REAL:
983 IssueReal issueReal = (IssueReal) issue;
984 ValueReal valueReal = (ValueReal) prevBid
985 .getValue(issueID);
986 ValueReal partnerValueReal = (ValueReal) partnerBid
987 .getValue(issueID);
988 double gap = Math.abs(valueReal.getValue()
989 - partnerValueReal.getValue());
990 if (gap > (issueReal.getUpperBound()
991 - issueReal.getLowerBound()) / 100) {
992 evalGap += 0.5;
993 }
994 break;
995 default:
996 if (!prevBid.getValue(issueID)
997 .equals(partnerBid.getValue(issueID))) {
998 evalGap += 0.5;
999 }
1000 break;
1001 }
1002
1003 Evaluator eval = ((AdditiveUtilitySpace) utilitySpace)
1004 .getEvaluator(issueID);
1005
1006 try {
1007 evalGap += Math.abs(eval.getEvaluation(
1008 ((AdditiveUtilitySpace) utilitySpace), prevBid,
1009 issueID)
1010 - eval.getEvaluation(
1011 ((AdditiveUtilitySpace) utilitySpace),
1012 partnerBid, issueID));
1013 } catch (Exception e) {
1014 evalGap += 1.0;
1015 }
1016
1017 evalGap += 0.5;
1018 }
1019
1020 evalGap /= 2.0 * issues.size();
1021
1022 if (time < 0.50) {
1023 if (prevPartnerBid != null
1024 && offeredUtil > maxCompromiseUtility
1025 && offeredUtil >= maxUtilityOfPartnerBid) {
1026 double acceptCoefficient = -0.1 * time + 1.0;
1027
1028 if (evalGap < 0.30 && offeredUtil > prevUtility
1029 * acceptCoefficient) {
1030 accept = true;
1031 }
1032 }
1033 } else if (time < 0.80) {
1034 if (prevPartnerBid != null
1035 && offeredUtil > maxCompromiseUtility * 0.95
1036 && offeredUtil > maxUtilityOfPartnerBid * 0.95) {
1037 double diffMyBidAndOffered = prevUtility - offeredUtil;
1038
1039 if (diffMyBidAndOffered < 0.0)
1040 diffMyBidAndOffered = 0.0;
1041
1042 double acceptCoefficient = -0.16 * (time - 0.50) + 0.95;
1043
1044 if (evalGap < 0.35 && offeredUtil > prevUtility
1045 * acceptCoefficient) {
1046 accept = true;
1047 }
1048 }
1049 } else {
1050
1051 if (prevPartnerBid != null
1052 && offeredUtil > maxCompromiseUtility * 0.90
1053 && offeredUtil > maxUtilityOfPartnerBid * 0.95) {
1054
1055 double restoreEvalGap = 0.0;
1056 for (Issue issue : issues) {
1057 int issueID = issue.getNumber();
1058
1059 switch (issue.getType()) {
1060 case REAL:
1061 IssueReal issueReal = (IssueReal) issue;
1062 ValueReal valueReal = (ValueReal) restoreBid
1063 .getValue(issueID);
1064 ValueReal partnerValueReal = (ValueReal) partnerBid
1065 .getValue(issueID);
1066 double gap = Math.abs(valueReal.getValue()
1067 - partnerValueReal.getValue());
1068 if (gap > (issueReal.getUpperBound()
1069 - issueReal.getLowerBound()) / 100) {
1070 restoreEvalGap += 0.5;
1071 }
1072 break;
1073 default:
1074 if (!restoreBid.getValue(issueID)
1075 .equals(partnerBid.getValue(issueID))) {
1076 restoreEvalGap += 0.5;
1077 }
1078 break;
1079 }
1080
1081 Evaluator eval = ((AdditiveUtilitySpace) utilitySpace)
1082 .getEvaluator(issueID);
1083
1084 try {
1085 restoreEvalGap += Math.abs(eval.getEvaluation(
1086 ((AdditiveUtilitySpace) utilitySpace),
1087 prevBid, issueID)
1088 - eval.getEvaluation(
1089 ((AdditiveUtilitySpace) utilitySpace),
1090 partnerBid, issueID));
1091 } catch (Exception e) {
1092 restoreEvalGap += 1.0;
1093 }
1094
1095 restoreEvalGap += 0.5;
1096 }
1097
1098 restoreEvalGap /= 2.0 * issues.size();
1099
1100 double threshold = 0.40;
1101
1102 if (time > (0.90)) {
1103 threshold = 0.50;
1104
1105 }
1106 if (restoreEvalGap <= threshold
1107 || evalGap <= threshold) {
1108 accept = true;
1109 }
1110 }
1111 }
1112 }
1113 } catch (Exception e) {
1114 accept = false;
1115 }
1116 return accept;
1117 }
1118
1119 /**
1120 * This function determines the accept probability for an offer. At t=0 it
1121 * will prefer high-utility offers. As t gets closer to 1, it will accept
1122 * lower utility offers with increasing probability. it will never accept
1123 * offers with utility 0.
1124 *
1125 * @param u
1126 * is the utility
1127 * @param t
1128 * is the time as fraction of the total available time (t=0 at
1129 * start, and t=1 at end time)
1130 * @return the probability of an accept at time t
1131 * @throws Exception
1132 * if you use wrong values for u or t.
1133 *
1134 */
1135 double Paccept(double u, double t1) throws Exception {
1136 double t = t1 * t1 * t1; // steeper increase when deadline approaches.
1137 if (u < 0 || u > 1.05)
1138 throw new Exception("utility " + u + " outside [0,1]");
1139 // normalization may be slightly off, therefore we have a broad boundary
1140 // up to 1.05
1141 if (t < 0 || t > 1)
1142 throw new Exception("time " + t + " outside [0,1]");
1143 if (u > 1.)
1144 u = 1;
1145 if (t == 0.5)
1146 return u;
1147 return (u - 2. * u * t
1148 + 2. * (-1. + t + Math.sqrt(sq(-1. + t) + u * (-1. + 2 * t))))
1149 / (-1. + 2 * t);
1150 }
1151
1152 double sq(double x) {
1153 return x * x;
1154 }
1155
1156 @Override
1157 public SupportedNegotiationSetting getSupportedNegotiationSetting() {
1158 return SupportedNegotiationSetting.getLinearUtilitySpaceInstance();
1159 }
1160
1161 @Override
1162 public String getDescription() {
1163 return "ANAC2010";
1164 }
1165
1166}
Note: See TracBrowser for help on using the repository browser.