1 | import logging
|
---|
2 | import time
|
---|
3 | from decimal import Decimal
|
---|
4 |
|
---|
5 | import numpy as np
|
---|
6 | from random import randint
|
---|
7 | from typing import cast
|
---|
8 |
|
---|
9 | from geniusweb.actions.Accept import Accept
|
---|
10 | from geniusweb.actions.Action import Action
|
---|
11 | from geniusweb.actions.Offer import Offer
|
---|
12 | from geniusweb.bidspace.AllBidsList import AllBidsList
|
---|
13 | from geniusweb.inform.ActionDone import ActionDone
|
---|
14 | from geniusweb.inform.Finished import Finished
|
---|
15 | from geniusweb.inform.Inform import Inform
|
---|
16 | from geniusweb.inform.Settings import Settings
|
---|
17 | from geniusweb.inform.YourTurn import YourTurn
|
---|
18 | from geniusweb.issuevalue.Bid import Bid
|
---|
19 | from geniusweb.party.Capabilities import Capabilities
|
---|
20 | from geniusweb.party.DefaultParty import DefaultParty
|
---|
21 | from geniusweb.profileconnection.ProfileConnectionFactory import (
|
---|
22 | ProfileConnectionFactory,
|
---|
23 | )
|
---|
24 | from geniusweb.progress.ProgressRounds import ProgressRounds
|
---|
25 | from tudelft_utilities_logging.Reporter import Reporter
|
---|
26 |
|
---|
27 |
|
---|
28 | class Agent29(DefaultParty):
|
---|
29 | """
|
---|
30 | Agent Hope
|
---|
31 |
|
---|
32 | Linear concession is used for target utilities.
|
---|
33 |
|
---|
34 | Each time a bid is to be chosen, a whole range of bids close to the target utility is considered from
|
---|
35 | which, the ones with values closest to the estimated opponent's preferred values are prioritised for
|
---|
36 | the final offer.
|
---|
37 |
|
---|
38 | Close to the deadline, the agent offers the bid with the highest utility from the set of all the bids
|
---|
39 | received.
|
---|
40 |
|
---|
41 | Bids are accepted only if the are sufficiently better than the average received bid.
|
---|
42 | This approach only accepts very good bids and only becomes more lenient towards the very end of
|
---|
43 | negotiation.
|
---|
44 |
|
---|
45 | It is ensured that no bid with utility lower than the agent's reservation value
|
---|
46 | is ever offered or accepted.
|
---|
47 | """
|
---|
48 |
|
---|
49 | def __init__(self, reporter: Reporter = None):
|
---|
50 | super().__init__(reporter)
|
---|
51 | self.getReporter().log(logging.INFO, "party is initialized")
|
---|
52 | self._profile = None
|
---|
53 | self._last_received_bid = None
|
---|
54 | self._reservation_value = 0.0
|
---|
55 | self._all_opponent_bids: list[Bid] = []
|
---|
56 | self._all_offered_bids: list[Bid] = []
|
---|
57 | self._log_times = [np.log(i / 200) for i in range(1, 201)]
|
---|
58 | self._log_times.insert(0, 0)
|
---|
59 | self._e = 1.0
|
---|
60 | self._last_ten_bids_counts = {}
|
---|
61 | self._all_possible_bids: AllBidsList
|
---|
62 | self._all_possible_bids_utils = []
|
---|
63 | self._all_possible_bids_ord: list[Bid] = []
|
---|
64 | self._all_possible_bids_ord_utils = []
|
---|
65 | self._num_possible_bids = 0
|
---|
66 |
|
---|
67 | def notifyChange(self, info: Inform):
|
---|
68 | """This is the entry point of all interaction with your agent after is has been initialised.
|
---|
69 |
|
---|
70 | Args:
|
---|
71 | info (Inform): Contains either a request for action or information.
|
---|
72 | """
|
---|
73 |
|
---|
74 | # a Settings message is the first message that will be sent to your
|
---|
75 | # agent containing all the information about the negotiation session.
|
---|
76 | if isinstance(info, Settings):
|
---|
77 | self._settings: Settings = cast(Settings, info)
|
---|
78 | self._me = self._settings.getID()
|
---|
79 |
|
---|
80 | # progress towards the deadline has to be tracked manually through the use of the Progress object
|
---|
81 | self._progress = self._settings.getProgress()
|
---|
82 |
|
---|
83 | # the profile contains the preferences of the agent over the domain
|
---|
84 | self._profile = ProfileConnectionFactory.create(
|
---|
85 | info.getProfile().getURI(), self.getReporter()
|
---|
86 | )
|
---|
87 |
|
---|
88 | # initialises the histogram opponent modelling
|
---|
89 | self.initialise_bid_counts()
|
---|
90 | self.initialise_all_possible_bids()
|
---|
91 | self.initialise_reservation_value()
|
---|
92 | # ActionDone is an action send by an opponent (an offer or an accept)
|
---|
93 | elif isinstance(info, ActionDone):
|
---|
94 | action: Action = cast(ActionDone, info).getAction()
|
---|
95 |
|
---|
96 | # if it is an offer, set the last received bid
|
---|
97 | if isinstance(action, Offer):
|
---|
98 | self._last_received_bid = cast(Offer, action).getBid()
|
---|
99 | # YourTurn notifies you that it is your turn to act
|
---|
100 | elif isinstance(info, YourTurn):
|
---|
101 | action = self._myTurn()
|
---|
102 | if isinstance(self._progress, ProgressRounds):
|
---|
103 | self._progress = self._progress.advance()
|
---|
104 | self.getConnection().send(action)
|
---|
105 |
|
---|
106 | # Finished will be sent if the negotiation has ended (through agreement or deadline)
|
---|
107 | elif isinstance(info, Finished):
|
---|
108 | # terminate the agent MUST BE CALLED
|
---|
109 | self.terminate()
|
---|
110 | else:
|
---|
111 | self.getReporter().log(
|
---|
112 | logging.WARNING, "Ignoring unknown info " + str(info)
|
---|
113 | )
|
---|
114 |
|
---|
115 | # lets the geniusweb system know what settings this agent can handle
|
---|
116 | # leave it as it is for this competition
|
---|
117 | def getCapabilities(self) -> Capabilities:
|
---|
118 | return Capabilities(
|
---|
119 | set(["SAOP"]),
|
---|
120 | set(["geniusweb.profile.utilityspace.LinearAdditive"]),
|
---|
121 | )
|
---|
122 |
|
---|
123 | # terminates the agent and its connections
|
---|
124 | # leave it as it is for this competition
|
---|
125 | def terminate(self):
|
---|
126 | self.getReporter().log(logging.INFO, "party is terminating:")
|
---|
127 | super().terminate()
|
---|
128 | if self._profile is not None:
|
---|
129 | self._profile.close()
|
---|
130 | self._profile = None
|
---|
131 |
|
---|
132 |
|
---|
133 |
|
---|
134 | # give a description of your agent
|
---|
135 | def getDescription(self) -> str:
|
---|
136 | return "Agent Hope: Linear concession is used for target utilities. \nEach time a bid is to be chosen, " \
|
---|
137 | "a whole range of bids close to the target utility is considered from which, the ones with values " \
|
---|
138 | "closest to the estimated opponent's preferred values are prioritised for the final offer. \nClose to " \
|
---|
139 | "the deadline, the agent offers the bid with the highest utility from the set of all the bids " \
|
---|
140 | "received. \nBids are accepted only if the are sufficiently better than the average received bid. " \
|
---|
141 | "This approach only accepts very good bids and only becomes more lenient towards the very end of " \
|
---|
142 | "negotiation. \nIt is ensured that no bid with utility lower than the agent's reservation value " \
|
---|
143 | "is ever offered or accepted."
|
---|
144 |
|
---|
145 | """
|
---|
146 | Execute a turn
|
---|
147 | """
|
---|
148 |
|
---|
149 | def _myTurn(self):
|
---|
150 | if self._last_received_bid is not None:
|
---|
151 | self._all_opponent_bids.append(self._last_received_bid)
|
---|
152 | if len(self._all_opponent_bids) != 0:
|
---|
153 | if len(self._all_opponent_bids) > 10:
|
---|
154 | self._uncount_oldest_bid()
|
---|
155 | self._count_last_bid()
|
---|
156 | # check if the last received offer of the opponent is good enough
|
---|
157 | if self._isGood(self._last_received_bid):
|
---|
158 | # if so, accept the offer
|
---|
159 | action = Accept(self._me, self._last_received_bid)
|
---|
160 | # checks if the negotiation is nearing the end. If so, the best received offer is sent
|
---|
161 | elif self._progress.get(time.time() * 1000) >= 0.95:
|
---|
162 | opp_bids_utilities = [self._profile.getProfile().getUtility(bid) for bid in self._all_opponent_bids]
|
---|
163 | best_opponent_bid = self._all_opponent_bids[np.argmax(opp_bids_utilities)]
|
---|
164 | if self._profile.getProfile().getUtility(best_opponent_bid) >= self._reservation_value:
|
---|
165 | action = Offer(self._me, best_opponent_bid)
|
---|
166 | else:
|
---|
167 | action = Offer(self._me, self._findBid())
|
---|
168 | else:
|
---|
169 | # if there is still time and the received offer was not good enough, the agent looks for a better one
|
---|
170 | bid = self._findBid()
|
---|
171 | action = Offer(self._me, bid)
|
---|
172 | self._all_offered_bids.append(bid)
|
---|
173 |
|
---|
174 | # send the action
|
---|
175 | return action
|
---|
176 |
|
---|
177 | """
|
---|
178 | The method that finds a bid in multiple possible ways based on the current situation.
|
---|
179 | If the opponent model is initialised, it uses it, otherwise a random bid is taken.
|
---|
180 | """
|
---|
181 |
|
---|
182 | def _findBid(self) -> Bid:
|
---|
183 | # find bids with utilities closest to the target utility
|
---|
184 | target_utility = Decimal(1.0 - 0.3 * self._progress.get(time.time() * 1000))
|
---|
185 | bids_to_consider = self.bids_close_to_target_util(target_utility)
|
---|
186 | # only keep bids with utility above reservation value
|
---|
187 | acceptable_bids = self.remove_bids_below_reservation(bids_to_consider)
|
---|
188 |
|
---|
189 | if len(acceptable_bids) == 0: # if no bids are acceptable, offer one with util >= reservation
|
---|
190 | best_bid = self.find_first_acceptable_bid()
|
---|
191 | elif len(self._all_opponent_bids) >= 10: # if the histogram is initialised, use it
|
---|
192 | best_bid = self.best_domain_bid(acceptable_bids)
|
---|
193 | else: # if the histogram is not initialised, offer random bids
|
---|
194 | # initialize the bid to something above reservation value
|
---|
195 | best_bid = self.find_first_acceptable_bid()
|
---|
196 | best_bid_util = self._profile.getProfile().getUtility(best_bid)
|
---|
197 |
|
---|
198 | # take attempts at finding a random bid that is acceptable to us
|
---|
199 | best_bid = self.find_random_acceptable_bid(best_bid, best_bid_util)
|
---|
200 |
|
---|
201 | return best_bid
|
---|
202 |
|
---|
203 | """
|
---|
204 | This method receives bids and checks whether they should be accepted. It is responsible for checking
|
---|
205 | the quality of bids the agent offers using a three stage approach depending on the progress (number of rounds
|
---|
206 | finished).
|
---|
207 |
|
---|
208 | In the first stage, it refuses any bids, which gives the agent enough time to learn about the opponent
|
---|
209 | (establish the average and start domain modeling).
|
---|
210 |
|
---|
211 | The second stage covers majority of the rounds and accepts offers only when the bid offered is significantly
|
---|
212 | better than average.
|
---|
213 |
|
---|
214 | In the last stage if an agreement hasn't been reached yet, any bid is accepted as long as it is better than the
|
---|
215 | reservation_value.
|
---|
216 | """
|
---|
217 |
|
---|
218 | def _isGood(self, bid: Bid) -> bool:
|
---|
219 | if bid is None:
|
---|
220 | return False
|
---|
221 |
|
---|
222 | # first stage - establish average of opponent
|
---|
223 | if self._progress.get(time.time() * 1000) < 0.2:
|
---|
224 | return False
|
---|
225 |
|
---|
226 | # second stage - check if the received bid improved by at least 50% above the average
|
---|
227 | if self._progress.get(time.time() * 1000) < 0.97:
|
---|
228 | return self._significantImprovement(bid, 0.5)
|
---|
229 |
|
---|
230 | # last part - this only gets executed if opponent doesn't accept an offer they sent previously.
|
---|
231 | return self._profile.getProfile().getUtility(bid) > self._reservation_value
|
---|
232 |
|
---|
233 | """
|
---|
234 | Check whether the offered bid has a utility greater than 0.8 (as well as greater than our reservation value)
|
---|
235 | Not elaborate, only used for the first 10 offered bids (opponent acceptance at this stage is not really expected)
|
---|
236 | """
|
---|
237 |
|
---|
238 | def _isGoodDomainAgent(self, bid: Bid) -> bool:
|
---|
239 | if bid is None:
|
---|
240 | return False
|
---|
241 | bid_util = self._profile.getProfile().getUtility(bid)
|
---|
242 | return bid_util > 0.8 and bid_util > self._reservation_value
|
---|
243 |
|
---|
244 | """
|
---|
245 | Following method checks whether a given bid is better than an average bid by at least the value specified
|
---|
246 | (significance).
|
---|
247 |
|
---|
248 | It also checks whether the bid is better than the reservationBid (if specified).
|
---|
249 | """
|
---|
250 |
|
---|
251 | def _significantImprovement(self, bid: Bid, significance: float) -> bool:
|
---|
252 | if len(self._all_opponent_bids) == 0:
|
---|
253 | return False
|
---|
254 |
|
---|
255 | # numpy average computation
|
---|
256 | get_util = lambda x: float(self._profile.getProfile().getUtility(x))
|
---|
257 | vgu = np.vectorize(get_util)
|
---|
258 | average = np.average(vgu(self._all_opponent_bids))
|
---|
259 |
|
---|
260 | return float(self._profile.getProfile().getUtility(bid)) > average + significance and \
|
---|
261 | float(self._profile.getProfile().getUtility(bid)) > self._reservation_value
|
---|
262 |
|
---|
263 | """
|
---|
264 | Initializes an empty histogram for use in the domain modeling.
|
---|
265 | """
|
---|
266 |
|
---|
267 | def initialise_bid_counts(self):
|
---|
268 | domain = self._profile.getProfile().getDomain()
|
---|
269 | domain_issues = domain.getIssues()
|
---|
270 |
|
---|
271 | self._num_possible_bids = 1
|
---|
272 | for issue in domain_issues:
|
---|
273 | self._last_ten_bids_counts[issue] = {}
|
---|
274 | issue_values = domain.getValues(issue)
|
---|
275 | self._num_possible_bids *= issue_values.size()
|
---|
276 | for issue_value in issue_values:
|
---|
277 | self._last_ten_bids_counts[issue][issue_value] = 0
|
---|
278 |
|
---|
279 | """
|
---|
280 | Initializes a list of bids in the agent's bid space, and sorts them as well.
|
---|
281 | """
|
---|
282 |
|
---|
283 | def initialise_all_possible_bids(self):
|
---|
284 | domain = self._profile.getProfile().getDomain()
|
---|
285 | self._all_possible_bids = AllBidsList(domain)
|
---|
286 | for i in range(self._all_possible_bids.size()):
|
---|
287 | current_bid = self._all_possible_bids.get(i)
|
---|
288 | self._all_possible_bids_utils.append(self._profile.getProfile().getUtility(current_bid))
|
---|
289 | self._all_possible_bids_utils = np.array(self._all_possible_bids_utils)
|
---|
290 | sort_indices = np.argsort(self._all_possible_bids_utils)
|
---|
291 | for i in range(self._all_possible_bids.size()):
|
---|
292 | self._all_possible_bids_ord.append(self._all_possible_bids.get(sort_indices[i]))
|
---|
293 |
|
---|
294 | self._all_possible_bids_ord_utils = self._all_possible_bids_utils[sort_indices]
|
---|
295 | self._all_possible_bids_ord_utils = self._all_possible_bids_ord_utils = \
|
---|
296 | self._all_possible_bids_ord_utils.astype('float')
|
---|
297 |
|
---|
298 | """
|
---|
299 | Initializes a reservation value, if a Reservation Bid is defined in the profile.
|
---|
300 | """
|
---|
301 |
|
---|
302 | def initialise_reservation_value(self):
|
---|
303 | reservation_bid = self._profile.getProfile().getReservationBid()
|
---|
304 | if reservation_bid is not None:
|
---|
305 | self._reservation_value = self._profile.getProfile().getUtility(reservation_bid)
|
---|
306 |
|
---|
307 | """
|
---|
308 | If the last received bid is not empty, add it to the histogram
|
---|
309 | """
|
---|
310 |
|
---|
311 | def _count_last_bid(self):
|
---|
312 | domain = self._profile.getProfile().getDomain()
|
---|
313 | domain_issues = domain.getIssues()
|
---|
314 |
|
---|
315 | for issue in domain_issues:
|
---|
316 | opponent_bid = self._last_received_bid
|
---|
317 | opp_bid_value = opponent_bid.getValue(issue)
|
---|
318 | if opp_bid_value is not None: # measure against the stupid agent
|
---|
319 | self._last_ten_bids_counts[issue][opp_bid_value] += 1
|
---|
320 |
|
---|
321 | """
|
---|
322 | Remove the 11th most recent (i.e. the no longer relevant) bid from the histogram
|
---|
323 | """
|
---|
324 |
|
---|
325 | def _uncount_oldest_bid(self):
|
---|
326 | domain = self._profile.getProfile().getDomain()
|
---|
327 | domain_issues = domain.getIssues()
|
---|
328 |
|
---|
329 | for issue in domain_issues:
|
---|
330 | oldest_relevant_opp_bid = self._all_opponent_bids[-10]
|
---|
331 | opp_bid_value = oldest_relevant_opp_bid.getValue(issue)
|
---|
332 | self._last_ten_bids_counts[issue][opp_bid_value] -= 1
|
---|
333 |
|
---|
334 | """
|
---|
335 | Return a number between 0 and 1 indicating how close the given bid is to the current opponent preference model.
|
---|
336 | """
|
---|
337 |
|
---|
338 | def domain_similarity(self, bid: Bid):
|
---|
339 | domain = self._profile.getProfile().getDomain()
|
---|
340 | domain_issues = domain.getIssues()
|
---|
341 | num_issues = len(domain_issues)
|
---|
342 |
|
---|
343 | similarity = 0.
|
---|
344 |
|
---|
345 | for issue in domain_issues:
|
---|
346 | opp_bid_value = bid.getValue(issue)
|
---|
347 | similarity += (self._last_ten_bids_counts[issue][opp_bid_value] / 10.0) / num_issues
|
---|
348 |
|
---|
349 | return similarity
|
---|
350 |
|
---|
351 | """
|
---|
352 | Sort the given bids by how close they are to our opponent's preference model (histograms).
|
---|
353 | """
|
---|
354 |
|
---|
355 | def sort_bids_by_similarity(self, bids_to_consider) -> list[Bid]:
|
---|
356 | bid_similarities = []
|
---|
357 | for i in bids_to_consider:
|
---|
358 | bid_similarities.append(self.domain_similarity(i))
|
---|
359 |
|
---|
360 | bid_similarities_sort_index = np.argsort(bid_similarities)[::-1]
|
---|
361 | sorted_bids = np.array(bids_to_consider)[bid_similarities_sort_index]
|
---|
362 |
|
---|
363 | return sorted_bids
|
---|
364 |
|
---|
365 | """
|
---|
366 | Iterates over the array of bids sorted by similarity and tries to pick the first that hasn't been offered yet.
|
---|
367 | If all bids from the list were already offered, the first bid is returned.
|
---|
368 | """
|
---|
369 |
|
---|
370 | def choose_bid_high_similarity(self, sorted_bids):
|
---|
371 | i = 0
|
---|
372 | chosen_bid = sorted_bids[i]
|
---|
373 | while chosen_bid in self._all_offered_bids and i < len(sorted_bids):
|
---|
374 | chosen_bid = sorted_bids[i]
|
---|
375 | i += 1
|
---|
376 | if i == len(self._all_offered_bids):
|
---|
377 | chosen_bid = sorted_bids[0]
|
---|
378 | return chosen_bid
|
---|
379 |
|
---|
380 | """
|
---|
381 | Choose a bid randomly with priority given to those with highest similarity.
|
---|
382 | The choice happens through roulette wheel selection with exponential probabilities (1/2, 1/4, 1/8, ...)
|
---|
383 | """
|
---|
384 |
|
---|
385 | def choose_bid_weighted_random(self, sorted_bids):
|
---|
386 | probabilities = [1 / 2 ** (i + 1) for i in range(len(sorted_bids))]
|
---|
387 | probabilities[-1] = probabilities[-2]
|
---|
388 |
|
---|
389 | cum_prob = np.cumsum(probabilities)
|
---|
390 | rnd_n = np.random.uniform()
|
---|
391 |
|
---|
392 | chosen_bid = None
|
---|
393 | for i in range(len(cum_prob)):
|
---|
394 | if rnd_n < cum_prob[i]:
|
---|
395 | chosen_bid = sorted_bids[i]
|
---|
396 | break
|
---|
397 | return chosen_bid
|
---|
398 |
|
---|
399 | """
|
---|
400 | From the given list, choose a bid with priority given to bids with high similarity to the opponent model.
|
---|
401 | Roughly 80% of bids will be chosen deterministically with choose_bid_high_similarity, the remaining 20% are chosen
|
---|
402 | randomly with roulette wheel selection.
|
---|
403 | """
|
---|
404 |
|
---|
405 | def best_domain_bid(self, bids_to_consider) -> Bid:
|
---|
406 | sorted_bids = self.sort_bids_by_similarity(bids_to_consider)
|
---|
407 |
|
---|
408 | choice_n = np.random.uniform()
|
---|
409 | exploration_constant = 0.8
|
---|
410 | if len(sorted_bids) == 1: # when only one bid is considered, return it
|
---|
411 | chosen_bid = sorted_bids[0]
|
---|
412 | elif choice_n < exploration_constant: # choose the bids with the highest similarity
|
---|
413 | chosen_bid = self.choose_bid_high_similarity(sorted_bids)
|
---|
414 | else: # choose a bid with weighted randomness
|
---|
415 | chosen_bid = self.choose_bid_weighted_random(sorted_bids)
|
---|
416 |
|
---|
417 | return chosen_bid
|
---|
418 |
|
---|
419 | """
|
---|
420 | From all possible bids, extract those that are close to the target utility.
|
---|
421 | 2 * fraction * 100% bids are expected to be extracted, but it can be less when the target utility is very high
|
---|
422 | (not enough bids with higher utility) or very low (not enough bids with lower utility)
|
---|
423 | """
|
---|
424 |
|
---|
425 | def bids_close_to_target_util(self, target_utility, fraction=0.025):
|
---|
426 | util_distances = np.abs(np.subtract(self._all_possible_bids_ord_utils, float(target_utility)))
|
---|
427 | closest_bid_index = np.argmin(util_distances)
|
---|
428 | radius = int(fraction * self._num_possible_bids) # number of bids to consider
|
---|
429 | bids_to_consider = self._all_possible_bids_ord[max(0, closest_bid_index - radius):
|
---|
430 | min(len(self._all_possible_bids_ord) - 1,
|
---|
431 | closest_bid_index + radius)]
|
---|
432 | return bids_to_consider
|
---|
433 |
|
---|
434 | """
|
---|
435 | From the given list of bids, remove all those that cannot be offered because of utility below reservation value.
|
---|
436 | """
|
---|
437 |
|
---|
438 | def remove_bids_below_reservation(self, bids_to_consider):
|
---|
439 | acceptable_bids = []
|
---|
440 | for i in range(len(bids_to_consider)):
|
---|
441 | if self._profile.getProfile().getUtility(bids_to_consider[i]) >= self._reservation_value:
|
---|
442 | acceptable_bids.append(bids_to_consider[i])
|
---|
443 | return acceptable_bids
|
---|
444 |
|
---|
445 | """
|
---|
446 | From all possible bids, choose the one with lowest utility that is higher than the reservation value.
|
---|
447 | """
|
---|
448 |
|
---|
449 | def find_first_acceptable_bid(self):
|
---|
450 | best_bid = None
|
---|
451 | for i in range(len(self._all_possible_bids_ord)):
|
---|
452 | if self._all_possible_bids_ord_utils[i] >= self._reservation_value:
|
---|
453 | best_bid = self._all_possible_bids_ord[i]
|
---|
454 | break
|
---|
455 | return best_bid
|
---|
456 |
|
---|
457 | """
|
---|
458 | Make a fixed number of attempts at finding a random bid that would be acceptable.
|
---|
459 | """
|
---|
460 |
|
---|
461 | def find_random_acceptable_bid(self, best_bid, best_bid_util, attempts=100):
|
---|
462 | for _ in range(attempts):
|
---|
463 | bid = self._all_possible_bids.get(randint(0, self._all_possible_bids.size() - 1))
|
---|
464 | if self._isGoodDomainAgent(bid): # if the bid is good, offer it
|
---|
465 | best_bid = bid
|
---|
466 | break
|
---|
467 | # if the bid is not good but better than the best so far, update it
|
---|
468 | if self._profile.getProfile().getUtility(bid) > best_bid_util:
|
---|
469 | best_bid = bid
|
---|
470 | best_bid_util = self._profile.getProfile().getUtility(bid)
|
---|
471 | return best_bid
|
---|