1 | package geniusweb.exampleparties.simpleshaop;
|
---|
2 |
|
---|
3 | import java.io.IOException;
|
---|
4 | import java.math.BigInteger;
|
---|
5 | import java.util.ArrayList;
|
---|
6 | import java.util.Arrays;
|
---|
7 | import java.util.Collections;
|
---|
8 | import java.util.HashSet;
|
---|
9 | import java.util.List;
|
---|
10 | import java.util.Random;
|
---|
11 | import java.util.logging.Level;
|
---|
12 |
|
---|
13 | import javax.websocket.DeploymentException;
|
---|
14 |
|
---|
15 | import geniusweb.actions.Accept;
|
---|
16 | import geniusweb.actions.Action;
|
---|
17 | import geniusweb.actions.Comparison;
|
---|
18 | import geniusweb.actions.ElicitComparison;
|
---|
19 | import geniusweb.actions.EndNegotiation;
|
---|
20 | import geniusweb.actions.Offer;
|
---|
21 | import geniusweb.actions.PartyId;
|
---|
22 | import geniusweb.bidspace.AllBidsList;
|
---|
23 | import geniusweb.inform.ActionDone;
|
---|
24 | import geniusweb.inform.Finished;
|
---|
25 | import geniusweb.inform.Inform;
|
---|
26 | import geniusweb.inform.Settings;
|
---|
27 | import geniusweb.inform.YourTurn;
|
---|
28 | import geniusweb.issuevalue.Bid;
|
---|
29 | import geniusweb.issuevalue.Domain;
|
---|
30 | import geniusweb.party.Capabilities;
|
---|
31 | import geniusweb.party.DefaultParty;
|
---|
32 | import geniusweb.profile.Profile;
|
---|
33 | import geniusweb.profileconnection.ProfileConnectionFactory;
|
---|
34 | import geniusweb.profileconnection.ProfileInterface;
|
---|
35 | import geniusweb.progress.Progress;
|
---|
36 | import geniusweb.progress.ProgressRounds;
|
---|
37 | import tudelft.utilities.logging.Reporter;
|
---|
38 |
|
---|
39 | /**
|
---|
40 | * This Agent work on partial preference and use the GravityAgent ( ANAC 2019
|
---|
41 | * competition ) user model to model user and use Frequency method to model our
|
---|
42 | * opponent.
|
---|
43 | *
|
---|
44 | * @author Arash Ebrahinezhad
|
---|
45 | *
|
---|
46 | * Arash.ebrah@gmail.com arash.ebrah@nit.ac.ir
|
---|
47 | */
|
---|
48 | public class ShaopParty extends DefaultParty {
|
---|
49 |
|
---|
50 | private Random rand = new Random();
|
---|
51 |
|
---|
52 | private int numberOfSameConsecutiveBidInMyBids = 0;
|
---|
53 | private double eCost; // Elicitation Cost
|
---|
54 | private double rValue; // Reservation Value
|
---|
55 | private FrequencyModel opModel; // Opponent Model
|
---|
56 | private boolean myConcessionEnough = false;
|
---|
57 | private GravityEs myModel2; // User Model
|
---|
58 | private Bid receivedBid = null; // Last Received bid
|
---|
59 | ArrayList<Bid> oppBids = new ArrayList<Bid>(); // All Bids that received from Opponent
|
---|
60 | ArrayList<Bid> myBids = new ArrayList<Bid>(); // All Bids that we sent to opponent
|
---|
61 | private List<Bid> bidOrder;
|
---|
62 | private int allBidSize;
|
---|
63 | private List<Double> expectedValue; // توزیع احتمالاتی بیدهای در بین بیدهای مرتب شده
|
---|
64 |
|
---|
65 | // Time depending bidding strategy : boulware or conceder
|
---|
66 | private double e = 0.8;
|
---|
67 | private static final double k = 0;
|
---|
68 | private int afterRank = 2; // How many rank after our estimation bid rank must be checked
|
---|
69 | private int beforeRank = 1; // How many rank before our estimation bid rank must be checked
|
---|
70 | private double agreementSimilarityThreshold; // threshold of similarity for acceptance Strategy
|
---|
71 | private double opponentConcesionRate = 0.08; // our expected opponent concession rate
|
---|
72 | private int howManyRankMustBeChecked = 5; // threshold of bid rank which we mast to check if Estimation rank satisfy
|
---|
73 | // the condition
|
---|
74 |
|
---|
75 | double Pagreement; // the threshold of bid agreement by opponent we must to select ( control our
|
---|
76 | // concession strategy )
|
---|
77 |
|
---|
78 | ////////////////////////////////////////////////////////////////////////////////////////////
|
---|
79 | private Bid reservationBid;
|
---|
80 | private PartyId me;
|
---|
81 | protected ProfileInterface profileint;
|
---|
82 | private Progress progress;
|
---|
83 |
|
---|
84 | private USpace utilitySpace;
|
---|
85 | private Profile profile;
|
---|
86 | private Domain domain;
|
---|
87 | private AllBidsList allBids;
|
---|
88 | private double totalBother = 0;
|
---|
89 | private SimpleLinearOrdering estimatedProfile = null;
|
---|
90 | ////////////////////////////////////////////////////////////////////////////////////////////
|
---|
91 |
|
---|
92 | public ShaopParty() {
|
---|
93 | }
|
---|
94 |
|
---|
95 | public ShaopParty(Reporter reporter) {
|
---|
96 | super(reporter); // for debugging
|
---|
97 | }
|
---|
98 |
|
---|
99 | private void init(Settings info) throws IOException, DeploymentException {
|
---|
100 |
|
---|
101 | Settings settings = info;
|
---|
102 | this.profileint = ProfileConnectionFactory.create(settings.getProfile().getURI(), getReporter());
|
---|
103 | this.me = settings.getID();
|
---|
104 | this.progress = settings.getProgress();
|
---|
105 |
|
---|
106 | this.profile = profileint.getProfile();
|
---|
107 | this.domain = this.profile.getDomain();
|
---|
108 | utilitySpace = new USpace(this.domain);
|
---|
109 | allBids = new AllBidsList(profileint.getProfile().getDomain());
|
---|
110 |
|
---|
111 | if (reservationBid != null) // if the reservation bid does not exist so we accept opponent bid with more
|
---|
112 | // probability
|
---|
113 | agreementSimilarityThreshold = 0.85;
|
---|
114 | else
|
---|
115 | agreementSimilarityThreshold = 0.7;
|
---|
116 |
|
---|
117 | estimatedProfile = new SimpleLinearOrdering(profile);
|
---|
118 | List<Bid> bOr = new ArrayList<Bid>();
|
---|
119 | if (estimatedProfile.getBids().size() == 2) { // if ordered bids size equal 2, add reservation value or random
|
---|
120 | // Bid
|
---|
121 |
|
---|
122 | bOr.add(estimatedProfile.getBids().get(0));
|
---|
123 |
|
---|
124 | if (reservationBid != null && !reservationBid.equals(estimatedProfile.getBids().get(0))
|
---|
125 | && !reservationBid.equals(estimatedProfile.getBids().get(1)))
|
---|
126 | bOr.add(reservationBid);
|
---|
127 | else
|
---|
128 | while (true) {
|
---|
129 | long i = rand.nextInt(allBids.size().intValue());
|
---|
130 | Bid randBid = allBids.get(BigInteger.valueOf(i));
|
---|
131 | if (!randBid.equals(estimatedProfile.getBids().get(0))
|
---|
132 | && !randBid.equals(estimatedProfile.getBids().get(1))) {
|
---|
133 | bOr.add(randBid);
|
---|
134 | break;
|
---|
135 | }
|
---|
136 | }
|
---|
137 |
|
---|
138 | bOr.add(estimatedProfile.getBids().get(1));
|
---|
139 |
|
---|
140 | estimatedProfile = new SimpleLinearOrdering(domain, bOr);
|
---|
141 |
|
---|
142 | }
|
---|
143 |
|
---|
144 | bidOrder = estimatedProfile.getBids();
|
---|
145 |
|
---|
146 | try { // if elicitation cost is set, catch it, else set it 0.1
|
---|
147 | eCost = (double) settings.getParameters().get("elicitationcost");
|
---|
148 | } catch (Exception e) {
|
---|
149 | eCost = 0.1; // if elicitation cost is not set, we set it to 0.1
|
---|
150 | }
|
---|
151 |
|
---|
152 | try { // if reservation Bid is set, catch it, else set it null
|
---|
153 | reservationBid = profile.getReservationBid();
|
---|
154 | } catch (Exception e) {
|
---|
155 | reservationBid = null;
|
---|
156 | }
|
---|
157 |
|
---|
158 | opModel = new FrequencyModel(utilitySpace);
|
---|
159 |
|
---|
160 | allBidSize = allBids.size().intValue();
|
---|
161 | expectedValue = new ArrayList<Double>();
|
---|
162 | initExpectedValue();
|
---|
163 |
|
---|
164 | myModel2 = new GravityEs(domain, bidOrder);
|
---|
165 |
|
---|
166 | // myModel = new WinkyA2(domain, bidOrder, profileint);
|
---|
167 |
|
---|
168 | if (reservationBid != null) // if reservation bid is set, set the reservation value to utility of it
|
---|
169 | rValue = myModel2.getUtilityForBid(reservationBid); // این قسمت شاید تغییر کند
|
---|
170 | else
|
---|
171 | rValue = 0;
|
---|
172 |
|
---|
173 | }
|
---|
174 |
|
---|
175 | public void initExpectedValue() {
|
---|
176 | for (int i = 0; i < bidOrder.size() - 1; i++)
|
---|
177 | expectedValue.add(1.0 / (bidOrder.size() - 1));
|
---|
178 |
|
---|
179 | }
|
---|
180 |
|
---|
181 | private void updateExpectedUtility() {
|
---|
182 | expectedValue.clear();
|
---|
183 | for (int i = 0; i < bidOrder.size() - 1; i++)
|
---|
184 | expectedValue.add(1.0 / (bidOrder.size() - 1));
|
---|
185 | }
|
---|
186 |
|
---|
187 | @Override
|
---|
188 | public void notifyChange(Inform info) {
|
---|
189 | try {
|
---|
190 | if (info instanceof Settings) {
|
---|
191 | init((Settings) info);
|
---|
192 | } else if (info instanceof ActionDone) {
|
---|
193 | Action otheract = ((ActionDone) info).getAction();
|
---|
194 | if (otheract instanceof Offer) {
|
---|
195 | receivedBid = ((Offer) otheract).getBid();
|
---|
196 | opModel.updateLearner(receivedBid);
|
---|
197 | } else if (otheract instanceof Comparison) {
|
---|
198 | totalBother += eCost; // شاید این قسمت تغییر کند
|
---|
199 | estimatedProfile = estimatedProfile.with(((Comparison) otheract).getBid(),
|
---|
200 | ((Comparison) otheract).getWorse());
|
---|
201 | bidOrder = estimatedProfile.getBids(); // After each elicitation update bidOrder
|
---|
202 | updateExpectedUtility();
|
---|
203 | myModel2 = myModel2.updateGravityModel(bidOrder); // After each elicitation update User Model
|
---|
204 | if (reservationBid != null)
|
---|
205 | rValue = myModel2.getUtilityForBid(reservationBid); // After each elicitation update reservation
|
---|
206 | // value
|
---|
207 | myTurn(true);
|
---|
208 | }
|
---|
209 | } else if (info instanceof YourTurn) {
|
---|
210 | myTurn(false);
|
---|
211 | } else if (info instanceof Finished) {
|
---|
212 | getReporter().log(Level.INFO, "Final ourcome:" + info);
|
---|
213 | }
|
---|
214 | } catch (Exception e) {
|
---|
215 | throw new RuntimeException("Failed to handle info", e);
|
---|
216 | }
|
---|
217 | }
|
---|
218 |
|
---|
219 | @Override
|
---|
220 | public Capabilities getCapabilities() {
|
---|
221 | return new Capabilities(new HashSet<>(Arrays.asList("SHAOP")), Collections.singleton(Profile.class));
|
---|
222 | }
|
---|
223 |
|
---|
224 | @Override
|
---|
225 | public String getDescription() {
|
---|
226 | return "Azar Agent ANAC 2020";
|
---|
227 | }
|
---|
228 |
|
---|
229 | /**
|
---|
230 | * Called when it's (still) our turn and we should take some action. Also
|
---|
231 | * Updates the progress if necessary.
|
---|
232 | */
|
---|
233 | void myTurn(boolean elicitation) throws IOException {
|
---|
234 |
|
---|
235 | Action action = null;
|
---|
236 |
|
---|
237 | if (!elicitation && !myConcessionEnough) {
|
---|
238 | double t = progress.get(System.currentTimeMillis());
|
---|
239 | Pagreement = getPagreement(t);
|
---|
240 | }
|
---|
241 |
|
---|
242 | // Elicitation Strategy and Bidding Strategy
|
---|
243 | // log2("--------------------------------<Elicitation
|
---|
244 | // start>------------------------------------"+Pagreement);
|
---|
245 | MyBidDetails bidDetail = null;
|
---|
246 |
|
---|
247 | if (totalBother < 0.6 /* 1-rValue */ ) { // تا زمانی که به مقدار رزرویشن نرسیدیم، الیسیتیشن رو ادامه بده
|
---|
248 | bidDetail = getBestBidInKnownSet(Pagreement, elicitation);
|
---|
249 |
|
---|
250 | MyBidDetails bidDetailPrim = getBestBidInUnKnownSet(Pagreement);
|
---|
251 |
|
---|
252 | // Only for log!!!
|
---|
253 | // String s = " Is this ("+bidDetailPrim.getEu()+" - "+eCost+" >
|
---|
254 | // "+bidDetail.getEu() + ") True?";
|
---|
255 | // s +=( (bidDetailPrim.getEu() - eCost > bidDetail.getEu()) ) ? " True =>
|
---|
256 | // Elicit" : " False => not Elicit";
|
---|
257 | // log2( s );
|
---|
258 |
|
---|
259 | if (bidDetailPrim.getEu() - eCost > bidDetail.getEu())
|
---|
260 | action = new ElicitComparison(me, bidDetailPrim.getBid(), estimatedProfile.getBids());
|
---|
261 |
|
---|
262 | } else {
|
---|
263 | // log2("Elicitation total bother is more than 0.6 !!!");
|
---|
264 | }
|
---|
265 | // log2("---------------------------------<Elicitation
|
---|
266 | // End>-------------------------------------\n\n");
|
---|
267 |
|
---|
268 | if (bidDetail == null) {
|
---|
269 | if (reservationBid != null)
|
---|
270 | bidDetail = new MyBidDetails(reservationBid, 0.5);
|
---|
271 | else if (bidOrder.size() > 10)
|
---|
272 | bidDetail = new MyBidDetails(bidOrder.get(bidOrder.size() / 2), 1.0);
|
---|
273 | else
|
---|
274 | bidDetail = new MyBidDetails(bidOrder.get(bidOrder.size() - 1), 1.0);
|
---|
275 | }
|
---|
276 |
|
---|
277 | if (action == null && receivedBid != null) {
|
---|
278 | if (isGood(receivedBid, bidDetail.getBid()))
|
---|
279 | action = new Accept(me, receivedBid);
|
---|
280 |
|
---|
281 | if (progress instanceof ProgressRounds)
|
---|
282 | progress = ((ProgressRounds) progress).advance();
|
---|
283 |
|
---|
284 | }
|
---|
285 |
|
---|
286 | if (action == null) {
|
---|
287 | Bid myBid = bidDetail.getBid();
|
---|
288 |
|
---|
289 | if (myModel2.getUtilityForBid(myBid) > rValue) {
|
---|
290 |
|
---|
291 | if (myBids.isEmpty())
|
---|
292 | myBids.add(myBid);
|
---|
293 | if (!myBids.contains(myBid))
|
---|
294 | myBids.add(myBid);
|
---|
295 |
|
---|
296 | if (myBids.size() > 1)
|
---|
297 | if (myBids.get(myBids.size() - 1).equals(myBids.get(myBids.size() - 2)))
|
---|
298 | numberOfSameConsecutiveBidInMyBids++;
|
---|
299 | else
|
---|
300 | numberOfSameConsecutiveBidInMyBids = 0;
|
---|
301 |
|
---|
302 | action = new Offer(me, myBid);
|
---|
303 | } else
|
---|
304 | action = new EndNegotiation(me);
|
---|
305 |
|
---|
306 | }
|
---|
307 |
|
---|
308 | getConnection().send(action);
|
---|
309 |
|
---|
310 | }
|
---|
311 |
|
---|
312 | // ***************************************************************************************
|
---|
313 |
|
---|
314 | /**
|
---|
315 | * Acceptance Strategy
|
---|
316 | *
|
---|
317 | * @param reBid the last received bid from opponent
|
---|
318 | *
|
---|
319 | * @param nextBid the next bid that we prepare to send to opponent
|
---|
320 | *
|
---|
321 | * @return true if we must accept opponent offer and false vice versa
|
---|
322 | */
|
---|
323 | private boolean isGood(Bid reBid, Bid nextBid) {
|
---|
324 |
|
---|
325 | if (oppBids.isEmpty() || !oppBids.contains(reBid)) // اگر این بید را قبلا دریافت نکرده باشیم اضافه کن
|
---|
326 | oppBids.add(reBid);
|
---|
327 |
|
---|
328 | if (myModel2.getUtilityForBid(reBid) < rValue)
|
---|
329 | return false;
|
---|
330 |
|
---|
331 | if (reBid.equals(nextBid))
|
---|
332 | return true;
|
---|
333 |
|
---|
334 | if (myBids.contains(reBid))
|
---|
335 | return true;
|
---|
336 |
|
---|
337 | if (myModel2.getUtilityForBid(reBid) >= myModel2.getUtilityForBid(nextBid))
|
---|
338 | return true;
|
---|
339 |
|
---|
340 | for (Bid b : myBids)
|
---|
341 | if (myModel2.getUtilityForBid(reBid) >= myModel2.getUtilityForBid(b) + 0.07)
|
---|
342 | return true;
|
---|
343 |
|
---|
344 | double currentAgreementSimilarityThreshold = ((1 - Pagreement) > agreementSimilarityThreshold)
|
---|
345 | ? (1 - Pagreement)
|
---|
346 | : agreementSimilarityThreshold;
|
---|
347 |
|
---|
348 | return (getAcceptanceProbability(reBid, nextBid) > currentAgreementSimilarityThreshold ? true : false)
|
---|
349 | && myModel2.getUtilityForBid(reBid) > rValue;
|
---|
350 |
|
---|
351 | }
|
---|
352 |
|
---|
353 | /**
|
---|
354 | *
|
---|
355 | * @param reBid Last Received Bid From Opponent
|
---|
356 | * @param nextBid the next bid that we prepare send to opponent
|
---|
357 | *
|
---|
358 | * @return double value that determine maximum similarity (1-distance) value of
|
---|
359 | * received bid from opponent to our sent bids
|
---|
360 | */
|
---|
361 | private double getAcceptanceProbability(Bid reBid, Bid nextBid) {
|
---|
362 |
|
---|
363 | double t = Double.MAX_VALUE;
|
---|
364 |
|
---|
365 | double reBidU = myModel2.getUtilityForBid(reBid);
|
---|
366 |
|
---|
367 | // for ( Bid b : oppBids ) {
|
---|
368 | for (Bid b : myBids) {
|
---|
369 | double temp = 1 - Math.abs(myModel2.getUtilityForBid(b) - reBidU);
|
---|
370 | if (temp < t) {
|
---|
371 | t = temp;
|
---|
372 | }
|
---|
373 | }
|
---|
374 |
|
---|
375 | double nextBidU = myModel2.getUtilityForBid(nextBid);
|
---|
376 | if ((1 - Math.abs(nextBidU - reBidU)) < t)
|
---|
377 | return (1 - Math.abs(nextBidU - reBidU));
|
---|
378 |
|
---|
379 | return t;
|
---|
380 |
|
---|
381 | }
|
---|
382 |
|
---|
383 | /**
|
---|
384 | *
|
---|
385 | * @param the Agreement probability of the bid that we want decide about its
|
---|
386 | * elicitation must be more than it.
|
---|
387 | *
|
---|
388 | * @return the best bid and its utility (MyBidDetails object) in the set of bids
|
---|
389 | * which we know about its order.
|
---|
390 | */
|
---|
391 | private MyBidDetails getBestBidInKnownSet(double Pagreement1, boolean elicitation) {
|
---|
392 |
|
---|
393 | for (int i = bidOrder.size() - 1; i > 0; i--) {
|
---|
394 | double Pat = getAgreementProbability(bidOrder.get(i));
|
---|
395 | if (Pat >= Pagreement1
|
---|
396 | && myModel2.getUtilityForBid(bidOrder.get(i)) > myModel2.getUtilityForBid(bidOrder.get(i)) / 2) {
|
---|
397 | if (myBids.size() > 1)
|
---|
398 | if (myModel2.getUtilityForBid(myBids.get(myBids.size() - 1))
|
---|
399 | - myModel2.getUtilityForBid(bidOrder.get(i)) > 0.3)
|
---|
400 | if (myModel2.getUtilityForBid(bidOrder.get(i)) - 0.3 > 0)
|
---|
401 | return new MyBidDetails(bidOrder.get(i), myModel2.getUtilityForBid(bidOrder.get(i)) - 0.3);
|
---|
402 | else
|
---|
403 | return new MyBidDetails(null, 0.0);
|
---|
404 |
|
---|
405 | return new MyBidDetails(bidOrder.get(i), myModel2.getUtilityForBid(bidOrder.get(i)));
|
---|
406 | }
|
---|
407 | }
|
---|
408 |
|
---|
409 | return new MyBidDetails(null, 0.0);
|
---|
410 |
|
---|
411 | /*
|
---|
412 | * if ( myBids.size() > 0 ) {
|
---|
413 | *
|
---|
414 | * if( myModel2.getUtilityForBid( myBids.get( myBids.size()-1
|
---|
415 | * ))-(numberOfSameConsecutiveBidInMyBids*0.1) > 0 ) return new
|
---|
416 | * MyBidDetails(myBids.get( myBids.size()-1 ), myModel2.getUtilityForBid(
|
---|
417 | * myBids.get( myBids.size()-1 ))-(numberOfSameConsecutiveBidInMyBids*0.1) );
|
---|
418 | * else return new MyBidDetails(myBids.get( myBids.size()-1 ), 0.0 );
|
---|
419 | *
|
---|
420 | * } else return new MyBidDetails(bidOrder.get( bidOrder.size()-1 ),
|
---|
421 | * myModel2.getUtilityForBid( bidOrder.get( bidOrder.size()-1 )) );
|
---|
422 | */
|
---|
423 |
|
---|
424 | }
|
---|
425 |
|
---|
426 | /**
|
---|
427 | *
|
---|
428 | * @param Pagreement2 the Agreement probability of the bid that we want decide
|
---|
429 | * about its elicitation must be more than it.
|
---|
430 | *
|
---|
431 | * @return the best bid in the bids set that we don't know about their orders
|
---|
432 | * respect to if we would elicit it.
|
---|
433 | */
|
---|
434 | private MyBidDetails getBestBidInUnKnownSet(double Pagreement2) {
|
---|
435 |
|
---|
436 | /*
|
---|
437 | * for decrease the size of variety Check the probabilities we check only bids
|
---|
438 | * with high estimation rank and high utility
|
---|
439 | */
|
---|
440 |
|
---|
441 | int estimateBidRank = 0;
|
---|
442 |
|
---|
443 | double EEu = 0;
|
---|
444 | Bid bestBid = null;
|
---|
445 |
|
---|
446 | for (Bid bid : allBids) {
|
---|
447 |
|
---|
448 | if (!bidOrder.contains(bid)) {
|
---|
449 |
|
---|
450 | double Pat = getAgreementProbability(bid);
|
---|
451 |
|
---|
452 | if (Pat > Pagreement2 /* && myModel2.getUtilityForBid(bid) > bidThreshold */ ) {
|
---|
453 |
|
---|
454 | estimateBidRank = getEstimateBidRank(bid);
|
---|
455 |
|
---|
456 | if (estimateBidRank >= (bidOrder.size() - 1) - howManyRankMustBeChecked) {
|
---|
457 |
|
---|
458 | double tempEu = getNewEu(estimateBidRank, bid);
|
---|
459 |
|
---|
460 | double tempEEu = tempEu/* Pat */;
|
---|
461 |
|
---|
462 | if (tempEEu > EEu) {
|
---|
463 | EEu = tempEEu;
|
---|
464 | bestBid = bid;
|
---|
465 | }
|
---|
466 |
|
---|
467 | }
|
---|
468 | }
|
---|
469 | }
|
---|
470 |
|
---|
471 | }
|
---|
472 | if (bestBid != null)
|
---|
473 | return new MyBidDetails(bestBid, EEu);
|
---|
474 |
|
---|
475 | else
|
---|
476 | return new MyBidDetails(null, 0.0);
|
---|
477 |
|
---|
478 | }
|
---|
479 |
|
---|
480 | /**
|
---|
481 | *
|
---|
482 | * @param bid the bid we want estimate about its bid rank with our current
|
---|
483 | * knowledge
|
---|
484 | * @return estimated bid rank
|
---|
485 | */
|
---|
486 | private int getEstimateBidRank(Bid bid) {
|
---|
487 |
|
---|
488 | double tempU = myModel2.getUtilityForBid(bid);
|
---|
489 |
|
---|
490 | int rank = 0;
|
---|
491 | for (Bid b : bidOrder) {
|
---|
492 |
|
---|
493 | double bU = myModel2.getUtilityForBid(b);
|
---|
494 |
|
---|
495 | if (tempU <= bU) {
|
---|
496 | break;
|
---|
497 | } else
|
---|
498 | rank++;
|
---|
499 |
|
---|
500 | }
|
---|
501 | if (rank == 0)
|
---|
502 | rank = 1;
|
---|
503 |
|
---|
504 | return rank;
|
---|
505 |
|
---|
506 | }
|
---|
507 |
|
---|
508 | /**
|
---|
509 | *
|
---|
510 | * @param rank the rank of the bid that we estimate with current knowledge
|
---|
511 | * @param bid the bid which we want estimate its utility if it is elicited
|
---|
512 | * @return the our expected utility of bid that if we would elicite it
|
---|
513 | */
|
---|
514 | private double getNewEu(int rank, Bid bid) {
|
---|
515 |
|
---|
516 | expectedValue.clear();
|
---|
517 | expectedValue = getNewExpectedValue(rank);
|
---|
518 |
|
---|
519 | double newEU = 0;
|
---|
520 | int bidOrderSize2 = bidOrder.size();
|
---|
521 |
|
---|
522 | if (rank == bidOrderSize2 - 1)
|
---|
523 | return myModel2.getUtilityForBid(bid);
|
---|
524 |
|
---|
525 | int aJ = 0;
|
---|
526 | for (int j = rank; j <= Integer.min(rank + afterRank, bidOrderSize2 - 1); j++) { // ما بعد
|
---|
527 |
|
---|
528 | List<Bid> bidOrderProbability2 = new ArrayList<Bid>();
|
---|
529 |
|
---|
530 | for (Bid b : bidOrder)
|
---|
531 | bidOrderProbability2.add(b);
|
---|
532 |
|
---|
533 | double probabilityBelong = expectedValue.get(j - 1);// *bidOrderSize2;
|
---|
534 |
|
---|
535 | bidOrderProbability2.add(j, bid);
|
---|
536 |
|
---|
537 | GravityEs modelProbability2 = new GravityEs(domain, bidOrderProbability2);
|
---|
538 |
|
---|
539 | newEU += probabilityBelong * (modelProbability2.getUtilityForBid(bid));
|
---|
540 | aJ++;
|
---|
541 | }
|
---|
542 | if (rank > 1) {
|
---|
543 | for (int j = rank - 1; j > Integer.min(Integer.max(0, aJ - 1), Integer.max(0, rank - beforeRank)); j--) { // ما
|
---|
544 | // قبل
|
---|
545 |
|
---|
546 | List<Bid> bidOrderProbability1 = new ArrayList<Bid>();
|
---|
547 |
|
---|
548 | for (Bid b : bidOrder)
|
---|
549 | bidOrderProbability1.add(b);
|
---|
550 |
|
---|
551 | double probabilityBelong = expectedValue.get(j - 1);// *bidOrderSize2;
|
---|
552 | bidOrderProbability1.add(j, bid);
|
---|
553 |
|
---|
554 | GravityEs modelProbability1 = new GravityEs(domain, bidOrderProbability1);
|
---|
555 |
|
---|
556 | newEU += probabilityBelong * (modelProbability1.getUtilityForBid(bid));
|
---|
557 |
|
---|
558 | }
|
---|
559 | }
|
---|
560 |
|
---|
561 | return newEU;
|
---|
562 |
|
---|
563 | }
|
---|
564 |
|
---|
565 | /**
|
---|
566 | *
|
---|
567 | * @param rank the rank of the bid that we estimate with current knowledge
|
---|
568 | * @return probability distribution of bid in variety ranks, that we want decide
|
---|
569 | * about its elicitation
|
---|
570 | */
|
---|
571 | private List<Double> getNewExpectedValue(int rank) {
|
---|
572 |
|
---|
573 | double certainty = (double) bidOrder.size() / allBidSize;
|
---|
574 |
|
---|
575 | List<Double> expectedValue = new ArrayList<Double>();
|
---|
576 | for (int i = 0; i < bidOrder.size(); i++)
|
---|
577 | expectedValue.add(1.0 / (bidOrder.size() - 1));
|
---|
578 |
|
---|
579 | double temp1 = expectedValue.size();
|
---|
580 | for (int i = rank; i > 0; i--) {
|
---|
581 | double ttemp = expectedValue.get(i - 1);
|
---|
582 | expectedValue.remove(i - 1);
|
---|
583 | expectedValue.add(i - 1, (temp1 * certainty) + ttemp);
|
---|
584 | temp1--;
|
---|
585 | }
|
---|
586 |
|
---|
587 | double temp2 = expectedValue.size() - 1;
|
---|
588 | for (int i = rank + 1; i <= expectedValue.size(); i++) {
|
---|
589 | double ttemp = expectedValue.get(i - 1);
|
---|
590 | expectedValue.remove(i - 1);
|
---|
591 | expectedValue.add(i - 1, (temp2 * certainty) + ttemp);
|
---|
592 | temp2--;
|
---|
593 | }
|
---|
594 |
|
---|
595 | double n = 0;
|
---|
596 | for (double t : expectedValue)
|
---|
597 | n += t;
|
---|
598 |
|
---|
599 | for (int i = 0; i < expectedValue.size(); i++) {
|
---|
600 | double tTemp = expectedValue.get(i);
|
---|
601 | expectedValue.remove(i);
|
---|
602 | expectedValue.add(i, tTemp / n);
|
---|
603 | }
|
---|
604 |
|
---|
605 | return expectedValue;
|
---|
606 |
|
---|
607 | }
|
---|
608 |
|
---|
609 | private double f(double t) {
|
---|
610 | if (e == 0)
|
---|
611 | return k;
|
---|
612 | double ft = k + (1 - k) * Math.pow(t, 1 / e);
|
---|
613 |
|
---|
614 | return ft;
|
---|
615 | }
|
---|
616 |
|
---|
617 | /**
|
---|
618 | *
|
---|
619 | * @param t Time (if we want use time for compute concession rate)
|
---|
620 | * @return double value that the agent must be found a bid that has Agreement
|
---|
621 | * Probability more than it.
|
---|
622 | */
|
---|
623 | private double getPagreement(double t) {
|
---|
624 |
|
---|
625 | // if ( reservationBid != null || t <= 0.7 )
|
---|
626 | return Pagreement + 0.01;
|
---|
627 | // else
|
---|
628 | // return Pagreement+0.01; // 0.02
|
---|
629 | // return 1 - ( myEstimateMin + (myEstimateMax - myEstimateMin) * (1 - f(t)) );
|
---|
630 | }
|
---|
631 |
|
---|
632 | /**
|
---|
633 | *
|
---|
634 | * Opponent Model
|
---|
635 | *
|
---|
636 | * @param bid the bid want to know its agreement probability with opponent
|
---|
637 | *
|
---|
638 | * @return double value which determine opponent agreement probability of the
|
---|
639 | * bid
|
---|
640 | *
|
---|
641 | */
|
---|
642 | private double getAgreementProbability(Bid bid) {
|
---|
643 |
|
---|
644 | if (oppBids.isEmpty()) { // if we don't got any bid from opponent
|
---|
645 | return 1.0;
|
---|
646 | }
|
---|
647 | if (myBids.contains(bid)) { // if we sent this bid before
|
---|
648 | return opponentConcesionRate * progress.get(System.currentTimeMillis());
|
---|
649 | }
|
---|
650 | if (oppBids.contains(bid)) { // if this bid is one of previous bids that we got from opponent
|
---|
651 | return 1.0;
|
---|
652 | }
|
---|
653 |
|
---|
654 | double t = Double.MAX_VALUE;
|
---|
655 |
|
---|
656 | for (Bid b : oppBids) {
|
---|
657 |
|
---|
658 | double temp = 1 - Math.abs(opModel.getOpponentUtilitySpace().getUtility(b)
|
---|
659 | - opModel.getOpponentUtilitySpace().getUtility(bid));
|
---|
660 |
|
---|
661 | if (temp < t) {
|
---|
662 | t = temp;
|
---|
663 | }
|
---|
664 |
|
---|
665 | }
|
---|
666 |
|
---|
667 | return t;
|
---|
668 |
|
---|
669 | }
|
---|
670 |
|
---|
671 | // **********************************************************
|
---|
672 | // **********************************************************
|
---|
673 | // **********************************************************
|
---|
674 | // *********************** Test *************************
|
---|
675 | // **********************************************************
|
---|
676 | // **********************************************************
|
---|
677 | // **********************************************************
|
---|
678 |
|
---|
679 | private void log(Object o) {
|
---|
680 |
|
---|
681 | System.err.println(o);
|
---|
682 |
|
---|
683 | }
|
---|
684 |
|
---|
685 | private void log2(Object o) {
|
---|
686 |
|
---|
687 | System.out.println(o);
|
---|
688 |
|
---|
689 | }
|
---|
690 |
|
---|
691 | }
|
---|