source: src/main/java/agents/BayesianAgentForAuction.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: 27.1 KB
RevLine 
[126]1package agents;
2
3import java.util.ArrayList;
4
5import agents.bayesianopponentmodel.BayesianOpponentModel;
6import agents.bayesianopponentmodel.OpponentModel;
7import agents.bayesianopponentmodel.OpponentModelUtilSpace;
8import genius.core.Agent;
9import genius.core.AgentParam;
10import genius.core.Bid;
11import genius.core.BidIterator;
12import genius.core.actions.Accept;
13import genius.core.actions.Action;
14import genius.core.actions.EndNegotiation;
15import genius.core.actions.Offer;
16import genius.core.analysis.BidPoint;
17import genius.core.analysis.BidSpace;
18import genius.core.tournament.VariablesAndValues.AgentParameterVariable;
19import genius.core.utility.AdditiveUtilitySpace;
20
21/**
22 * Wrapper for opponentmodelspace, so that it is a neat utilityspace that we can
23 * give to the bidspace.
24 *
25 * @author wouter
26 *
27 */
28
29public class BayesianAgentForAuction extends Agent {
30
31 protected Action messageOpponent;
32 protected Bid myLastBid = null;
33 protected Action myLastAction = null;
34 protected Bid fOpponentPreviousBid = null;
35
36 protected enum ROLE {
37 CENTER, PROVIDER, IRRELEVANT
38 };
39
40 public enum PHASE {
41 FIRST_PHASE, SECOND_PHASE
42 };
43
44 protected enum ACTIONTYPE {
45 START, OFFER, ACCEPT, BREAKOFF
46 };
47
48 private enum STRATEGY {
49 SMART, SERIAL, RESPONSIVE, RANDOM, TIT_FOR_TAT, AUCTION
50 };
51
52 private STRATEGY fStrategy = STRATEGY.AUCTION;
53 private boolean fMarketPreassure = false;
54 protected int fSmartSteps;
55 protected OpponentModel fOpponentModel;
56 protected OpponentModel[] fOpponentModels = null;
57 protected double CONCESSIONFACTOR = 0.04;
58 private static final double ALLOWED_UTILITY_DEVIATION = 0.01;
59 protected static final int NUMBER_OF_SMART_STEPS = 0;
60 protected ArrayList<Bid> myPreviousBids;
61 private boolean fDebug = false;
62 protected PHASE fPhase = null;
63 protected ROLE fRole;
64
65 // Class constructor
66 public BayesianAgentForAuction() {
67 super();
68
69 }
70
71 @Override
72 public String getVersion() {
73 return "2.0";
74 }
75
76 /** Dummy variables, for testing only. W.Pasman 19aug08 */
77 public static ArrayList<AgentParam> getParameters() {
78 ArrayList<AgentParam> parameters = new ArrayList<AgentParam>();
79 parameters.add(new AgentParam(BayesianAgentForAuction.class.getName(),
80 "reservation", 0., 1.));
81 parameters.add(new AgentParam(BayesianAgentForAuction.class.getName(),
82 "starting_utility", 0., 1.));
83 parameters.add(new AgentParam(BayesianAgentForAuction.class.getName(),
84 "role", -1., 3.));
85 parameters.add(new AgentParam(BayesianAgentForAuction.class.getName(),
86 "phase", -1., 1.));
87 parameters.add(new AgentParam(BayesianAgentForAuction.class.getName(),
88 "opponent", -1., 1.));
89 return parameters;
90 }
91
92 public void init() {
93 messageOpponent = null;
94 myLastAction = null;
95 fSmartSteps = 0;
96 myPreviousBids = new ArrayList<Bid>();
97 fOpponentPreviousBid = null;
98 if ((getParameterValues().isEmpty())
99 || (getParameterValues().get(
100 new AgentParameterVariable(new AgentParam(
101 BayesianAgentForAuction.class.getName(),
102 "phase", new Double(-1.), new Double(1.))))
103 .getValue() < 0))
104 fPhase = PHASE.FIRST_PHASE;
105 else
106 fPhase = PHASE.SECOND_PHASE;
107 if (getParameterValues().isEmpty())
108 fRole = ROLE.IRRELEVANT;
109 else if ((getParameterValues().get(
110 new AgentParameterVariable(new AgentParam(
111 BayesianAgentForAuction.class.getName(), "role", -1.,
112 3.))).getValue() < 0))
113 fRole = ROLE.PROVIDER;
114 else if (getParameterValues().get(
115 new AgentParameterVariable(new AgentParam(
116 BayesianAgentForAuction.class.getName(), "role", -1.,
117 3.))).getValue() < 2) {
118 fRole = ROLE.CENTER;
119 CONCESSIONFACTOR = 0.06;
120 } else
121 fRole = ROLE.IRRELEVANT;
122 if ((fPhase == PHASE.FIRST_PHASE) && (fOpponentModels == null))
123 prepareOpponentModel();
124 if (fRole == ROLE.CENTER) {
125 int index = Double.valueOf(
126 getParameterValues().get(
127 new AgentParameterVariable(new AgentParam(
128 BayesianAgentForAuction.class.getName(),
129 "opponent", -1., 1.))).getValue())
130 .intValue();
131 fOpponentModel = fOpponentModels[index];
132 }
133
134 }
135
136 protected void prepareOpponentModel() {
137 fOpponentModels = new BayesianOpponentModel[2];
138 fOpponentModels[0] = new BayesianOpponentModel(
139 (AdditiveUtilitySpace) utilitySpace);
140 fOpponentModels[1] = new BayesianOpponentModel(
141 (AdditiveUtilitySpace) utilitySpace);
142 fOpponentModel = fOpponentModels[0];
143 }
144
145 // Class methods
146 public void ReceiveMessage(Action opponentAction) {
147 messageOpponent = opponentAction;
148 }
149
150 protected Action proposeInitialBid() throws Exception {
151 Bid lBid = null;
152 switch (fRole) {
153 case CENTER:
154 switch (fPhase) {
155 case FIRST_PHASE:
156 lBid = getMaxUtilityBid();
157 break;
158 case SECOND_PHASE:
159 double lSecondBest = getParameterValues().get(
160 new AgentParameterVariable(new AgentParam(
161 BayesianAgentForAuction.class.getName(),
162 "reservation", 0., 1.))).getValue();
163 lBid = getTradeOff(lSecondBest);
164 break;
165 }
166 break;
167 case PROVIDER:
168 switch (fPhase) {
169 case FIRST_PHASE:
170 double lReservationValue = utilitySpace.getReservationValue();// parametervalues.get("reservation");
171 lBid = getTradeOff(lReservationValue);
172 break;
173 case SECOND_PHASE:
174 lBid = getMaxUtilityBid();
175 break;
176 }
177 break;
178 case IRRELEVANT:
179 switch (fPhase) {
180 case FIRST_PHASE:
181 // if(fRole=ROLE.)
182 lBid = getMaxUtilityBid();
183 break;
184 case SECOND_PHASE:
185 double lSecondBest = getParameterValues().get(
186 new AgentParameterVariable(new AgentParam(
187 BayesianAgentForAuction.class.getName(),
188 "starting_utility", 0., 1.))).getValue();
189 lBid = getTradeOff(lSecondBest);
190 break;
191 }
192 break;
193 }
194 // Return (one of the) possible bid(s) with maximal utility.
195 fSmartSteps = NUMBER_OF_SMART_STEPS;
196 myLastBid = lBid;
197 return new Offer(getAgentID(), lBid);
198 }
199
200 /**
201 *
202 * @param pOppntBid
203 * @return a counterbid that has max util for us and an opponent utility
204 * that is equal to 1-estimated utility of opponent's last bid. Or,
205 * if that bid was done already before, another bid that has same
206 * utility in our space as that counterbid.
207 * @throws Exception
208 */
209 protected Bid getNextBidAuction(Bid pOppntBid) throws Exception {
210 if (pOppntBid == null)
211 throw new NullPointerException("pOpptBid=null");
212 if (myLastBid == null)
213 throw new Exception("myLastBid==null");
214 log("Get next bid ...");
215 Bid lBid = null;
216
217 switch (fRole) {
218 case CENTER:
219 switch (fPhase) {
220 case FIRST_PHASE:
221 lBid = getNextBidSmart(pOppntBid);
222 break;
223 case SECOND_PHASE:
224 double lSecondBest = getParameterValues().get(
225 new AgentParameterVariable(new AgentParam(
226 BayesianAgentForAuction.class.getName(),
227 "reservation", 0., 1.))).getValue();
228 lBid = getTradeOff(lSecondBest);
229 break;
230 }
231 break;
232 case PROVIDER:
233 switch (fPhase) {
234 case FIRST_PHASE:
235 double lReservationValue = utilitySpace.getReservationValue();// parametervalues.get("reservation");
236 lBid = getTradeOff(lReservationValue);
237 break;
238 case SECOND_PHASE:
239 lBid = getNextBidSmart(pOppntBid);
240 break;
241 }
242 break;
243 case IRRELEVANT:
244 switch (fPhase) {
245 case FIRST_PHASE:
246 lBid = getNextBidSmart(pOppntBid);
247 break;
248 case SECOND_PHASE:
249 lBid = getNextBidSmart(pOppntBid);
250 break;
251 }
252 break;
253
254 }
255 return lBid;
256 }
257
258 /**
259 *
260 * @param pOppntBid
261 * @return a counterbid that has max util for us and an opponent utility
262 * that is equal to 1-estimated utility of opponent's last bid. Or,
263 * if that bid was done already before, another bid that has same
264 * utility in our space as that counterbid.
265 * @throws Exception
266 */
267 private Bid getNextBid(Bid pOppntBid) throws Exception {
268 if (pOppntBid == null)
269 throw new NullPointerException("pOpptBid=null");
270 if (myLastBid == null)
271 throw new Exception("myLastBid==null");
272 log("Get next bid ...");
273
274 BidSpace bs = new BidSpace((AdditiveUtilitySpace) utilitySpace,
275 new OpponentModelUtilSpace(fOpponentModel), true, true);
276 // System.out.println("Bidspace:\n"+bs);
277
278 // compute opponent's concession
279 double opponentConcession = 0.;
280 if (fOpponentPreviousBid == null)
281 opponentConcession = 0;
282 else {
283 double opponentUtil = fOpponentModel
284 .getNormalizedUtility(pOppntBid);
285 double opponentFirstBidUtil = fOpponentModel
286 .getNormalizedUtility(fOpponentModel.fBiddingHistory.get(0));
287 opponentConcession = opponentUtil - opponentFirstBidUtil;
288 }
289 log("opponent Concession:" + opponentConcession);
290
291 // determine our bid point
292 double OurFirstBidOppUtil = fOpponentModel
293 .getNormalizedUtility(myPreviousBids.get(0));
294 double OurTargetBidOppUtil = OurFirstBidOppUtil - opponentConcession;
295 if (OurTargetBidOppUtil > 1)
296 OurTargetBidOppUtil = 1.;
297 if (OurTargetBidOppUtil < OurFirstBidOppUtil)
298 OurTargetBidOppUtil = OurFirstBidOppUtil;
299 log("our target opponent utility=" + OurTargetBidOppUtil);
300
301 // find the target on the pareto curve
302 double targetUtil = bs.ourUtilityOnPareto(OurTargetBidOppUtil);
303
304 BidPoint bp = bs.getNearestBidPoint(targetUtil, OurTargetBidOppUtil,
305 .5, 1, myPreviousBids);
306 log("found bid " + bp);
307 return bp.getBid();
308 }
309
310 /**
311 * get a new bid (not done before) that has ourUtility for us.
312 *
313 * @param ourUtility
314 * @return the bid with max opponent utility that is close to ourUtility. or
315 * null if there is no such bid.
316 */
317 Bid getNewBidWithUtil(double ourUtility, BidSpace bs) {
318 BidPoint bestbid = null;
319 double bestbidutil = 0;
320 for (BidPoint p : bs.bidPoints) {
321 if (Math.abs(ourUtility - p.getUtilityA()) < ALLOWED_UTILITY_DEVIATION
322 && p.getUtilityB() > bestbidutil
323 && !myPreviousBids.contains(p.getBid())) {
324 bestbid = p;
325 bestbidutil = p.getUtilityB();
326 }
327 }
328 if (bestbid == null)
329 return null;
330 return bestbid.getBid();
331 }
332
333 /**
334 * Wouter: Try to find a bid that has same utility for ourself but max
335 * utility for opponent.
336 *
337 * @author Dmytro
338 * @param pBid
339 * @return
340 * @throws Exception
341 */
342 protected Bid getSmartBid(Bid pBid) throws Exception {
343 Bid lBid = null;
344 double lExpectedUtility = -1;
345 double lUtility = utilitySpace.getUtility(pBid);
346 BidIterator lIter = new BidIterator(utilitySpace.getDomain());
347 // int i=1;
348 while (lIter.hasNext()) {
349 Bid tmpBid = lIter.next();
350 // System.out.println(tmpBid);
351 // System.out.println(String.valueOf(i++));
352 if (Math.abs(utilitySpace.getUtility(tmpBid) - lUtility) < ALLOWED_UTILITY_DEVIATION) {
353 // double lTmpSim = fSimilarity.getSimilarity(tmpBid,
354 // pOppntBid);
355 double lTmpExpecteUtility = fOpponentModel
356 .getNormalizedUtility(tmpBid);
357 if (lTmpExpecteUtility > lExpectedUtility) {
358 lExpectedUtility = lTmpExpecteUtility;
359 lBid = tmpBid;
360 }
361 }
362 }
363 return lBid;
364 // check if really found a better bid. if not return null
365 /*
366 * if(fOpponentModel.getNormalizedUtility(lBid)>(fOpponentModel.
367 * getNormalizedUtility(pBid)+0.04)) return lBid; else return null;
368 */
369 }
370
371 protected Bid getNextBidSmart(Bid pOppntBid) throws Exception {
372 double lMyUtility, lOppntUtility, lTargetUtility;
373 // Both parties have made an initial bid. Compute associated utilities
374 // from my point of view.
375 lMyUtility = utilitySpace.getUtility(myLastBid);
376 lOppntUtility = utilitySpace.getUtility(pOppntBid);
377 if (fSmartSteps >= NUMBER_OF_SMART_STEPS) {
378 lTargetUtility = getTargetUtility(lMyUtility, lOppntUtility);
379 fSmartSteps = 0;
380 } else {
381 lTargetUtility = lMyUtility;
382 fSmartSteps++;
383 }
384 if (lTargetUtility < utilitySpace.getReservationValue())
385 return null;
386 else
387 return getTradeOff(lTargetUtility);
388 }
389
390 protected Bid getTradeOff(double pUtility) throws Exception {
391 if (pUtility < utilitySpace.getReservationValue())
392 return null;
393 Bid lBid = null;
394 double lExpectedUtility = -100;
395 BidIterator lIter = new BidIterator(utilitySpace.getDomain());
396 // int i=1;
397 while (lIter.hasNext()) {
398 Bid tmpBid = lIter.next();
399 // System.out.println(tmpBid);
400 // System.out.println(String.valueOf(i++));
401 if (fMarketPreassure)
402 if (fNegotiation.getOpponentUtility(this, tmpBid) < 0.3)
403 continue;
404 if (Math.abs(utilitySpace.getUtility(tmpBid) - pUtility) < ALLOWED_UTILITY_DEVIATION) {
405 // double lTmpSim = fSimilarity.getSimilarity(tmpBid,
406 // pOppntBid);
407 double lTmpExpecteUtility = fNegotiation.getOpponentUtility(
408 this, tmpBid); // fOpponentModel.getExpectedUtility(tmpBid);
409 if (lTmpExpecteUtility > lExpectedUtility) {
410 lExpectedUtility = lTmpExpecteUtility;
411 lBid = tmpBid;
412 }
413 }
414 } // while
415 return lBid;
416 }
417
418 protected Bid proposeNextBid(Bid pOppntBid) throws Exception {
419 Bid lBid = null;
420 switch (fStrategy) {
421 case TIT_FOR_TAT:
422 lBid = getNextBid(pOppntBid);
423 break;
424 case SMART:
425 lBid = getNextBidSmart(pOppntBid);
426 break;
427 case AUCTION:
428 lBid = getNextBidAuction(pOppntBid);
429 break;
430 default:
431 throw new Exception("unknown strategy " + fStrategy);
432 }
433 myLastBid = lBid;
434 return lBid;
435 }
436
437 public double getOpponentUtility(Bid bid) throws Exception {
438 return fOpponentModel.getExpectedUtility(bid);
439 }
440
441 public Action chooseAction() {
442 Action lAction = null;
443 ACTIONTYPE lActionType;
444 Bid lOppntBid = null;
445
446 try {
447 lActionType = getActionType(messageOpponent);
448 switch (lActionType) {
449 case OFFER: // Offer received from opponent
450 lOppntBid = ((Offer) messageOpponent).getBid();
451 // if (fOpponentModel.haveSeenBefore(lOppntBid)) {
452 // lAction=myLastAction; break; }
453 // double lDistance = calculateEuclideanDistanceUtilitySpace();
454 // if(myLastAction==null) dumpDistancesToLog(0);
455 System.out.print("Updating beliefs ...");
456 if (myPreviousBids.size() < 8)
457 fOpponentModel.updateBeliefs(lOppntBid);
458 // dumpDistancesToLog(fRound++);
459 System.out.println("Done!");
460 if (myLastAction == null)
461 // Other agent started, lets propose my initial bid.
462 lAction = proposeInitialBid();
463 else {
464 double offeredutil = utilitySpace.getUtility(lOppntBid);
465 double time = timeline.getTime();
466 double P = Paccept(offeredutil, time);
467 log("time=" + time + " offeredutil=" + offeredutil
468 + " accept probability P=" + P);
469 if (utilitySpace.getUtility(lOppntBid) * 1.05 >= utilitySpace
470 .getUtility(myLastBid)
471 /* || .05*P>Math.random() */) {
472 // Opponent bids equally, or outbids my previous bid, so
473 // lets accept
474 lAction = new Accept(getAgentID(), lOppntBid);
475 log("randomly accepted");
476 } else {
477 Bid lnextBid = proposeNextBid(lOppntBid);
478 if (lnextBid == null) {
479 lAction = new EndNegotiation(getAgentID());
480 } else {
481
482 lAction = new Offer(getAgentID(), lnextBid);
483
484 // Propose counteroffer. Get next bid.
485 // Check if utility of the new bid is lower than
486 // utility of the opponent's last bid
487 // if yes then accept last bid of the opponent.
488 if (utilitySpace.getUtility(lOppntBid) * 1.05 >= utilitySpace
489 .getUtility(lnextBid)) {
490 // Opponent bids equally, or outbids my previous
491 // bid, so lets accept
492 lAction = new Accept(getAgentID(), lOppntBid);
493 log("opponent's bid higher than util of my last bid! accepted");
494 }
495 }
496
497 }
498 // remember current bid of the opponent as its previous bid
499 fOpponentPreviousBid = lOppntBid;
500 }
501 break;
502 case ACCEPT:
503 case BREAKOFF:
504 // nothing left to do. Negotiation ended, which should be
505 // checked by
506 // Negotiator...
507 break;
508 default:
509 // I am starting, but not sure whether Negotiator checks this,
510 // so
511 // lets check also myLastAction...
512 if (myLastAction == null) {
513 // dumpDistancesToLog(fRound++);
514 lAction = proposeInitialBid();
515 } else
516 // simply repeat last action
517 lAction = myLastAction;
518 break;
519 }
520 } catch (Exception e) {
521 log("Exception in chooseAction:" + e.getMessage());
522 e.printStackTrace();
523 lAction = new Offer(getAgentID(), myLastBid);
524 }
525 myLastAction = lAction;
526 {
527 myPreviousBids.add(((Offer) myLastAction).getBid());
528 myLastBid = ((Offer) myLastAction).getBid();
529 }
530 return lAction;
531 }
532
533 protected ACTIONTYPE getActionType(Action lAction) {
534 ACTIONTYPE lActionType = ACTIONTYPE.START;
535 if (lAction instanceof Offer)
536 lActionType = ACTIONTYPE.OFFER;
537 else if (lAction instanceof Accept)
538 lActionType = ACTIONTYPE.ACCEPT;
539 else if (lAction instanceof EndNegotiation)
540 lActionType = ACTIONTYPE.BREAKOFF;
541 return lActionType;
542 }
543
544 private double getTargetUtility(double myUtility, double oppntUtility) {
545 return myUtility - getConcessionFactor();
546 }
547
548 private double getConcessionFactor() {
549 // The more the agent is willing to concess on its aspiration value, the
550 // higher this factor.
551 return CONCESSIONFACTOR;
552 }
553
554 /**
555 * Prints out debug information only if the fDebug = true
556 *
557 * @param pMessage
558 * - debug informaton to print
559 */
560 private void log(String pMessage) {
561 if (fDebug)
562 System.out.println(pMessage);
563 }
564
565 /**
566 * This function determines the accept probability for an offer. At t=0 it
567 * will prefer high-utility offers. As t gets closer to 1, it will accept
568 * lower utility offers with increasing probability. it will never accept
569 * offers with utility 0.
570 *
571 * @param u
572 * is the utility
573 * @param t
574 * is the time as fraction of the total available time (t=0 at
575 * start, and t=1 at end time)
576 * @return the probability of an accept at time t
577 * @throws Exception
578 * if you use wrong values for u or t.
579 *
580 */
581 protected double Paccept(double u, double t1) throws Exception {
582 double t = t1 * t1 * t1; // get more relaxed more to the end.
583 if (u < 0 || u > 1.05)
584 throw new Exception("utility " + u + " outside [0,1]");
585 if (t < 0 || t > 1)
586 throw new Exception("time " + t + " outside [0,1]");
587 if (u > 1.)
588 u = 1.;
589
590 if (t == 0.5)
591 return u;
592 return (u - 2. * u * t + 2. * (-1. + t + Math.sqrt(sq(-1. + t) + u
593 * (-1. + 2 * t))))
594 / (-1. + 2 * t);
595 }
596
597 private double sq(double x) {
598 return x * x;
599 }
600
601 /*
602 * private double calculateEuclideanDistanceUtilitySpace(double[]
603 * pLearnedUtil, double[] pOpponentUtil) { double lDistance = 0; try {
604 * for(int i=0;i<pLearnedUtil.length;i++) lDistance = lDistance + sq(
605 * pOpponentUtil[i]-pLearnedUtil[i]); } catch (Exception e) {
606 * e.printStackTrace(); } lDistance = lDistance /
607 * utilitySpace.getDomain().getNumberOfPossibleBids(); return lDistance; }
608 * private double calculateEuclideanDistanceWeghts(double[] pExpectedWeight)
609 * { double lDistance = 0; int i=0; try { for(Issue lIssue :
610 * utilitySpace.getDomain().getIssues()) { lDistance = lDistance
611 * +sq(fNegotiation.getOpponentWeight(this, lIssue.getNumber())
612 * -pExpectedWeight[i]); i++; } } catch (Exception e) { e.printStackTrace();
613 * } return lDistance/(double)i; }
614 *
615 * private double calculatePearsonDistanceUtilitySpace(double[]
616 * pLearnedUtility, double[] pOpponentUtil) { double lDistance = 0; double
617 * lAverageLearnedUtil=0; double lAverageOriginalUtil=0; //calculate average
618 * values for(int i=0;i<pLearnedUtility.length;i++) { lAverageLearnedUtil =
619 * lAverageLearnedUtil + pLearnedUtility[i]; lAverageOriginalUtil =
620 * lAverageOriginalUtil + pOpponentUtil[i]; } lAverageLearnedUtil =
621 * lAverageLearnedUtil
622 * /(double)(utilitySpace.getDomain().getNumberOfPossibleBids());
623 * lAverageOriginalUtil = lAverageOriginalUtil/
624 * (double)(utilitySpace.getDomain().getNumberOfPossibleBids()); //calculate
625 * the distance itself double lSumX=0; double lSumY=0; for(int
626 * i=0;i<pLearnedUtility.length;i++) { lDistance = lDistance +
627 * (pLearnedUtility[i]-lAverageLearnedUtil)*
628 * (pOpponentUtil[i]-lAverageOriginalUtil); lSumX = lSumX +
629 * sq(pLearnedUtility[i]-lAverageLearnedUtil); lSumY = lSumY +
630 * sq(pOpponentUtil[i]-lAverageOriginalUtil);
631 *
632 * }
633 *
634 *
635 * return lDistance/(Math.sqrt(lSumX*lSumY)); }
636 *
637 * private double calculatePearsonDistanceWeghts(double[] pExpectedWeight) {
638 * double lDistance = 0; double lAverageLearnedWeight=0; double
639 * lAverageOriginalWeight=0; int i=0; try { for(Issue lIssue :
640 * utilitySpace.getDomain().getIssues()) { lAverageLearnedWeight =
641 * lAverageLearnedWeight +pExpectedWeight[i]; lAverageOriginalWeight =
642 * lAverageOriginalWeight + fNegotiation.getOpponentWeight(this,
643 * lIssue.getNumber()); i++; } } catch (Exception e) { e.printStackTrace();
644 * } lAverageLearnedWeight = lAverageLearnedWeight/(double)(i);
645 * lAverageOriginalWeight= lAverageOriginalWeight/ (double)(i);
646 *
647 * //calculate the distance itself i=0; double lSumX=0; double lSumY=0; try
648 * { for(Issue lIssue : utilitySpace.getDomain().getIssues()) { lDistance =
649 * lDistance +(fNegotiation.getOpponentWeight(this, lIssue.getNumber())-
650 * lAverageOriginalWeight)*(pExpectedWeight[i]-lAverageLearnedWeight); lSumX
651 * = lSumX + sq(fNegotiation.getOpponentWeight(this, lIssue.getNumber())-
652 * lAverageOriginalWeight); lSumY = lSumY +
653 * sq(pExpectedWeight[i]-lAverageLearnedWeight); i++; } } catch (Exception
654 * e) { e.printStackTrace(); }
655 *
656 * return lDistance/(Math.sqrt(lSumX*lSumY)); } private double
657 * calculateRankingDistanceUtilitySpaceMonteCarlo(double[] pLearnedUtil,
658 * double[] pOpponentUtil) { double lDistance = 0; int lNumberOfPossibleBids
659 * = (int)(utilitySpace.getDomain().getNumberOfPossibleBids()); int
660 * lNumberOfComparisons = 10000000; for(int k=0;k<lNumberOfComparisons ;k++)
661 * { int i = (new Random()).nextInt(lNumberOfPossibleBids-1); int j = (new
662 * Random()).nextInt(lNumberOfPossibleBids-1);
663 * if(((pLearnedUtil[i]>pLearnedUtil
664 * [j])&&(pOpponentUtil[i]>pOpponentUtil[j]))||
665 * ((pLearnedUtil[i]<pLearnedUtil
666 * [j])&&(pOpponentUtil[i]<pOpponentUtil[j]))||
667 * ((pLearnedUtil[i]==pLearnedUtil
668 * [j])&&(pOpponentUtil[i]==pOpponentUtil[j]))) {
669 *
670 * } else lDistance++;
671 *
672 * } return ((double)lDistance)/((double)lNumberOfComparisons); } private
673 * double calculateRankingDistanceUtilitySpace(double[] pLearnedUtil,
674 * double[] pOpponentUtil) {
675 *
676 * double lDistance = 0; int lNumberOfPossibleBids =
677 * (int)(utilitySpace.getDomain().getNumberOfPossibleBids());
678 *
679 * try { for(int i=0;i<lNumberOfPossibleBids-1;i++) { for(int
680 * j=i+1;j<lNumberOfPossibleBids;j++) { //if(i==j) continue; if
681 * (Math.signum(
682 * pLearnedUtil[i]-pLearnedUtil[j])!=Math.signum(pOpponentUtil[i
683 * ]-pOpponentUtil[j])) lDistance++;
684 *
685 * } //for } //for } catch (Exception e) { e.printStackTrace(); }
686 *
687 * lDistance = 2 * lDistance /
688 * (utilitySpace.getDomain().getNumberOfPossibleBids
689 * ()*(utilitySpace.getDomain().getNumberOfPossibleBids())); return
690 * lDistance; } private double calculateRankingDistanceWeghts(double
691 * pExpectedWeights[]) { double lDistance = 0; double[] lOriginalWeights =
692 * new double[utilitySpace.getDomain().getIssues().size()]; int k=0; try {
693 * for(Issue lIssue : utilitySpace.getDomain().getIssues()) {
694 * lOriginalWeights[k] = fNegotiation.getOpponentWeight(this,
695 * lIssue.getNumber()); k++; } } catch (Exception e) { e.printStackTrace();
696 * } k=0; int nrOfIssues = utilitySpace.getDomain().getIssues().size();
697 * for(int i=0; i<nrOfIssues-1;i++) { for(int j=i+1;j<nrOfIssues;j++) { k++;
698 * double tmpWeightLearned = pExpectedWeights[i]; double tmpWeightOriginal =
699 * lOriginalWeights[i]; double tmpWeight2Learned = pExpectedWeights[j];
700 * double tmpWeight2Original = lOriginalWeights[j];
701 * if(((tmpWeightLearned>tmpWeight2Learned
702 * )&&(tmpWeightOriginal>tmpWeight2Original))||
703 * ((tmpWeightLearned<tmpWeight2Learned
704 * )&&(tmpWeightOriginal<tmpWeight2Original))||
705 * ((tmpWeightLearned==tmpWeight2Learned
706 * )&&(tmpWeightOriginal==tmpWeight2Original))) {
707 *
708 * } else lDistance++;
709 *
710 * } } return ((double)lDistance)/((double)k); }
711 *
712 * protected void dumpDistancesToLog(int pRound) { if (fSkipDistanceCalc)
713 * return; System.out.print(getName() +
714 * ": calculating distance between the learned space and the original one ..."
715 * );
716 *
717 * double lExpectedWeights[] = new
718 * double[utilitySpace.getDomain().getIssues().size()]; int i=0; for(Issue
719 * lIssue : utilitySpace.getDomain().getIssues()) {
720 * lExpectedWeights[i]=fOpponentModel.getExpectedWeight(i); i++; }
721 *
722 *
723 * double pLearnedUtil[] = new
724 * double[(int)(utilitySpace.getDomain().getNumberOfPossibleBids())]; //
725 * HashMap<Bid, Double> pLearnedSpace = new HashMap<Bid, Double>();
726 * BidIterator lIter = new BidIterator( utilitySpace.getDomain()); i=0;
727 * while(lIter.hasNext()) { Bid lBid = lIter.next(); try { pLearnedUtil[i]
728 * =fOpponentModel.getNormalizedUtility(lBid); // pLearnedSpace.put(lBid,
729 * new Double(pLearnedUtil[i]));
730 *
731 * } catch (Exception e) { e.printStackTrace(); } i++; } double
732 * pOpponentUtil[] = new
733 * double[(int)(utilitySpace.getDomain().getNumberOfPossibleBids())]; //
734 * HashMap<Bid, Double> pOpponentSpace = new HashMap<Bid, Double>(); lIter =
735 * new BidIterator( utilitySpace.getDomain()); i=0; while(lIter.hasNext()) {
736 * Bid lBid = lIter.next(); try { pOpponentUtil[i] =
737 * fNegotiation.getOpponentUtility(this, lBid); // pOpponentSpace.put(lBid,
738 * new Double(pOpponentUtil[i])); } catch (Exception e) {
739 * e.printStackTrace(); } i++; }
740 *
741 * double lEuclideanDistUtil =
742 * calculateEuclideanDistanceUtilitySpace(pLearnedUtil,pOpponentUtil);
743 * double lEuclideanDistWeights =
744 * calculateEuclideanDistanceWeghts(lExpectedWeights); double
745 * lRankingDistUtil = 0;
746 * if((int)(utilitySpace.getDomain().getNumberOfPossibleBids())>100000)
747 * lRankingDistUtil =
748 * calculateRankingDistanceUtilitySpaceMonteCarlo(pLearnedUtil,
749 * pOpponentUtil); else lRankingDistUtil =
750 * calculateRankingDistanceUtilitySpace(pLearnedUtil, pOpponentUtil); double
751 * lRankingDistWeights = calculateRankingDistanceWeghts(lExpectedWeights);
752 * double lPearsonDistUtil =
753 * calculatePearsonDistanceUtilitySpace(pLearnedUtil,pOpponentUtil); double
754 * lPearsonDistWeights = calculatePearsonDistanceWeghts(lExpectedWeights);
755 * SimpleElement lLearningPerformance = new
756 * SimpleElement("learning_performance");
757 * lLearningPerformance.setAttribute("round", String.valueOf(pRound));
758 * lLearningPerformance.setAttribute("euclidean_distance_utility_space",
759 * String.valueOf(lEuclideanDistUtil));
760 * lLearningPerformance.setAttribute("euclidean_distance_weights",
761 * String.valueOf(lEuclideanDistWeights));
762 * lLearningPerformance.setAttribute("ranking_distance_utility_space",
763 * String.valueOf(lRankingDistUtil));
764 * lLearningPerformance.setAttribute("ranking_distance_weights",
765 * String.valueOf(lRankingDistWeights));
766 * lLearningPerformance.setAttribute("pearson_distance_utility_space",
767 * String.valueOf(lPearsonDistUtil));
768 * lLearningPerformance.setAttribute("pearson_distance_weights",
769 * String.valueOf(lPearsonDistWeights)); System.out.println("Done!");
770 * System.out.println(lLearningPerformance.toString());
771 * fNegotiation.addAdditionalLog(lLearningPerformance);
772 *
773 * }
774 */
775 public final Bid getMaxUtilityBid() throws Exception {
776 Bid maxBid = null;
777 double maxutil = 0.;
778 BidIterator bidit = new BidIterator(utilitySpace.getDomain());
779
780 if (bidit.hasNext())
781 maxBid = bidit.next();
782 else
783 throw new Exception("The domain does not contain any bids!");
784 while (bidit.hasNext()) {
785 Bid thisBid = bidit.next();
786 if (fMarketPreassure)
787 if (fNegotiation.getOpponentUtility(this, thisBid) < 0.3)
788 continue;
789 double thisutil = utilitySpace.getUtility(thisBid);
790 if (thisutil > maxutil) {
791 maxutil = thisutil;
792 maxBid = thisBid;
793 }
794 }
795 return maxBid;
796 }
797
798}
Note: See TracBrowser for help on using the repository browser.