1 | #######################################################
|
---|
2 | # author: Arash Ebrahimnezhad
|
---|
3 | # Email: Arash.ebrah@gmail.com
|
---|
4 | #######################################################
|
---|
5 | import logging
|
---|
6 | from random import randint
|
---|
7 | import random
|
---|
8 | from time import time
|
---|
9 | from tkinter.messagebox import NO
|
---|
10 | from typing import cast
|
---|
11 | import math
|
---|
12 | import pickle
|
---|
13 | import os
|
---|
14 | from statistics import mean
|
---|
15 | from geniusweb.actions.Accept import Accept
|
---|
16 | from geniusweb.actions.Action import Action
|
---|
17 | from geniusweb.actions.Offer import Offer
|
---|
18 | from geniusweb.actions.PartyId import PartyId
|
---|
19 | from geniusweb.bidspace.AllBidsList import AllBidsList
|
---|
20 | from geniusweb.inform.ActionDone import ActionDone
|
---|
21 | from geniusweb.inform.Finished import Finished
|
---|
22 | from geniusweb.inform.Inform import Inform
|
---|
23 | from geniusweb.inform.Settings import Settings
|
---|
24 | from geniusweb.inform.YourTurn import YourTurn
|
---|
25 | from geniusweb.issuevalue.Bid import Bid
|
---|
26 | from geniusweb.issuevalue.Domain import Domain
|
---|
27 | from geniusweb.party.Capabilities import Capabilities
|
---|
28 | from geniusweb.party.DefaultParty import DefaultParty
|
---|
29 | from geniusweb.profile.utilityspace.LinearAdditiveUtilitySpace import (
|
---|
30 | LinearAdditiveUtilitySpace,
|
---|
31 | )
|
---|
32 | from geniusweb.profileconnection.ProfileConnectionFactory import (
|
---|
33 | ProfileConnectionFactory,
|
---|
34 | )
|
---|
35 | from geniusweb.progress.ProgressTime import ProgressTime
|
---|
36 | from geniusweb.references.Parameters import Parameters
|
---|
37 | from tudelft_utilities_logging.ReportToLogger import ReportToLogger
|
---|
38 | from tudelft.utilities.immutablelist.ImmutableList import ImmutableList
|
---|
39 | from .utils.opponent_model import OpponentModel
|
---|
40 | from geniusweb.profile.utilityspace.LinearAdditive import LinearAdditive
|
---|
41 | from agents.time_dependent_agent.extended_util_space import ExtendedUtilSpace
|
---|
42 | from decimal import Decimal
|
---|
43 | from geniusweb.opponentmodel import FrequencyOpponentModel
|
---|
44 |
|
---|
45 |
|
---|
46 | NUMBER_OF_GOALS = 5
|
---|
47 |
|
---|
48 |
|
---|
49 | class LuckyAgent2022(DefaultParty):
|
---|
50 | """
|
---|
51 | Template of a Python geniusweb agent.
|
---|
52 | """
|
---|
53 |
|
---|
54 | def __init__(self):
|
---|
55 | super().__init__()
|
---|
56 | self.logger: ReportToLogger = self.getReporter()
|
---|
57 |
|
---|
58 | self.domain: Domain = None
|
---|
59 | self.parameters: Parameters = None
|
---|
60 | self.profile: LinearAdditiveUtilitySpace = None
|
---|
61 | self.progress: ProgressTime = None
|
---|
62 | self.me: PartyId = None
|
---|
63 | self.other: str = None
|
---|
64 | self.settings: Settings = None
|
---|
65 | self.storage_dir: str = None
|
---|
66 |
|
---|
67 | self.last_received_bid: Bid = None
|
---|
68 |
|
---|
69 | self.received_bid_details = []
|
---|
70 | self.my_bid_details = []
|
---|
71 | self.best_received_bid = None
|
---|
72 |
|
---|
73 | self.logger.log(logging.INFO, "party is initialized")
|
---|
74 | self.alpha = 1.0
|
---|
75 | self.betta = 0.0
|
---|
76 | # self.pattern = randint(0, PATTERN_SIZE)
|
---|
77 | self.agreement_utility = 0.0
|
---|
78 | self._utilspace: LinearAdditive = None # type:ignore
|
---|
79 | self.who_accepted = None
|
---|
80 |
|
---|
81 | self.is_called = False
|
---|
82 |
|
---|
83 | # ************* Parameters *************
|
---|
84 | self.max = 1.0
|
---|
85 | self.min = 0.6
|
---|
86 | self.e = 0.05
|
---|
87 | self.increasing_e = 0.025
|
---|
88 | self.decreasing_e = 0.025
|
---|
89 | self.epsilon = 1.0
|
---|
90 | self.good_agreement_u = 0.95
|
---|
91 | self.condition_d = 0
|
---|
92 |
|
---|
93 | def ff(self, ll, n):
|
---|
94 | x_list = []
|
---|
95 | for x in ll[::-1]:
|
---|
96 | if x[1] == n:
|
---|
97 | x_list.append(x[0])
|
---|
98 | else:
|
---|
99 | break
|
---|
100 | if len(x_list) > 0:
|
---|
101 | m = mean(x_list)
|
---|
102 | else:
|
---|
103 | m = 0.8
|
---|
104 | return m
|
---|
105 |
|
---|
106 | def set_parameters(self, opp):
|
---|
107 | if not os.path.exists(f"{self.storage_dir}/m_data"):
|
---|
108 | self.min = 0.6
|
---|
109 | self.e = 0.05
|
---|
110 | else:
|
---|
111 | rand_num = random.random()
|
---|
112 | saved_data = self.return_saved_data('m_data')
|
---|
113 | condition_data = self.return_saved_data('c_data')
|
---|
114 | if opp in saved_data:
|
---|
115 | self.good_agreement_u = self.good_agreement_u - \
|
---|
116 | (len(saved_data[opp]) * 0.01)
|
---|
117 | if self.good_agreement_u < 0.7:
|
---|
118 | self.good_agreement_u = 0.7
|
---|
119 | if len(saved_data[opp]) >= 2:
|
---|
120 | if (saved_data[opp][-2][0] == 0 and saved_data[opp][-1][0] > 0) or ((saved_data[opp][-2][1] == saved_data[opp][-1][1]) and (saved_data[opp][-2][2] == saved_data[opp][-1][2])):
|
---|
121 | self.condition_d = condition_data[opp] + \
|
---|
122 | saved_data[opp][-1][0]
|
---|
123 | if 0 <= self.condition_d < 1:
|
---|
124 | self.condition_d = 1
|
---|
125 | self.epsilon = self.epsilon / self.condition_d
|
---|
126 | if rand_num > self.epsilon:
|
---|
127 | self.min = saved_data[opp][-1][1]
|
---|
128 | self.e = saved_data[opp][-1][2]
|
---|
129 | else:
|
---|
130 | if saved_data[opp][-1][0] > 0 and saved_data[opp][-1][0] < self.good_agreement_u:
|
---|
131 | self.min = saved_data[opp][-1][1] + \
|
---|
132 | self.increasing_e
|
---|
133 | if self.min > 0.7:
|
---|
134 | self.min = 0.7
|
---|
135 | self.e = saved_data[opp][-1][2] - \
|
---|
136 | self.increasing_e
|
---|
137 | if self.e < 0.005:
|
---|
138 | self.e = 0.005
|
---|
139 | if saved_data[opp][-1][0] == 0:
|
---|
140 | self.condition_d = condition_data[opp] - (
|
---|
141 | 1-self.ff(saved_data[opp], saved_data[opp][-1][1]))
|
---|
142 | if self.condition_d < 0:
|
---|
143 | self.condition_d = 0
|
---|
144 | self.min = saved_data[opp][-1][1] - \
|
---|
145 | self.decreasing_e
|
---|
146 | if self.min < 0.5:
|
---|
147 | self.min = 0.5
|
---|
148 | self.e = saved_data[opp][-1][2] + \
|
---|
149 | self.decreasing_e
|
---|
150 | if self.e > 0.1:
|
---|
151 | self.e = 0.1
|
---|
152 | if saved_data[opp][-1][0] >= self.good_agreement_u:
|
---|
153 | self.min = saved_data[opp][-1][1]
|
---|
154 | self.e = saved_data[opp][-1][2]
|
---|
155 | else:
|
---|
156 | if saved_data[opp][-1][0] > 0 and saved_data[opp][-1][0] < self.good_agreement_u:
|
---|
157 | self.min = saved_data[opp][-1][1] + \
|
---|
158 | self.increasing_e
|
---|
159 | if self.min > 0.7:
|
---|
160 | self.min = 0.7
|
---|
161 | self.e = saved_data[opp][-1][2] - self.increasing_e
|
---|
162 | if self.e < 0.005:
|
---|
163 | self.e = 0.005
|
---|
164 | if saved_data[opp][-1][0] == 0:
|
---|
165 | self.condition_d = condition_data[opp] - (
|
---|
166 | 1-self.ff(saved_data[opp], saved_data[opp][-1][1]))
|
---|
167 | if self.condition_d < 0:
|
---|
168 | self.condition_d = 0
|
---|
169 | self.min = saved_data[opp][-1][1] - \
|
---|
170 | self.decreasing_e
|
---|
171 | if self.min < 0.5:
|
---|
172 | self.min = 0.5
|
---|
173 | self.e = saved_data[opp][-1][2] + self.decreasing_e
|
---|
174 | if self.e > 0.1:
|
---|
175 | self.e = 0.1
|
---|
176 | if saved_data[opp][-1][0] >= self.good_agreement_u:
|
---|
177 | self.min = saved_data[opp][-1][1]
|
---|
178 | self.e = saved_data[opp][-1][2]
|
---|
179 | else:
|
---|
180 | if saved_data[opp][-1][0] > 0 and saved_data[opp][-1][0] < self.good_agreement_u:
|
---|
181 | self.min = saved_data[opp][-1][1] + self.increasing_e
|
---|
182 | if self.min > 0.7:
|
---|
183 | self.min = 0.7
|
---|
184 | self.e = saved_data[opp][-1][2] - self.increasing_e
|
---|
185 | if self.e < 0.005:
|
---|
186 | self.e = 0.005
|
---|
187 | if saved_data[opp][-1][0] == 0:
|
---|
188 | self.condition_d = condition_data[opp] - (
|
---|
189 | 1-self.ff(saved_data[opp], saved_data[opp][-1][1]))
|
---|
190 | if self.condition_d < 0:
|
---|
191 | self.condition_d = 0
|
---|
192 | self.min = saved_data[opp][-1][1] - self.decreasing_e
|
---|
193 | if self.min < 0.5:
|
---|
194 | self.min = 0.5
|
---|
195 | self.e = saved_data[opp][-1][2] + self.decreasing_e
|
---|
196 | if self.e > 0.1:
|
---|
197 | self.e = 0.1
|
---|
198 | if saved_data[opp][-1][0] >= self.good_agreement_u:
|
---|
199 | self.min = saved_data[opp][-1][1]
|
---|
200 | self.e = saved_data[opp][-1][2]
|
---|
201 | else:
|
---|
202 | self.min = 0.6
|
---|
203 | self.e = 0.05
|
---|
204 |
|
---|
205 | def return_saved_data(self, file_name):
|
---|
206 | # for reading also binary mode is important
|
---|
207 | file = open(f"{self.storage_dir}/{file_name}", 'rb')
|
---|
208 | saved_data = pickle.load(file)
|
---|
209 | file.close()
|
---|
210 | return saved_data
|
---|
211 |
|
---|
212 | def notifyChange(self, data: Inform):
|
---|
213 | """MUST BE IMPLEMENTED
|
---|
214 | This is the entry point of all interaction with your agent after is has been initialised.
|
---|
215 | How to handle the received data is based on its class type.
|
---|
216 | Args:
|
---|
217 | info (Inform): Contains either a request for action or information.
|
---|
218 | """
|
---|
219 |
|
---|
220 | # a Settings message is the first message that will be send to your
|
---|
221 | # agent containing all the information about the negotiation session.
|
---|
222 | if isinstance(data, Settings):
|
---|
223 | self.settings = cast(Settings, data)
|
---|
224 | self.me = self.settings.getID()
|
---|
225 |
|
---|
226 | # progress towards the deadline has to be tracked manually through the use of the Progress object
|
---|
227 | self.progress = self.settings.getProgress()
|
---|
228 |
|
---|
229 | self.parameters = self.settings.getParameters()
|
---|
230 | self.storage_dir = self.parameters.get("storage_dir")
|
---|
231 |
|
---|
232 | # the profile contains the preferences of the agent over the domain
|
---|
233 | profile_connection = ProfileConnectionFactory.create(
|
---|
234 | data.getProfile().getURI(), self.getReporter()
|
---|
235 | )
|
---|
236 | self.profile = profile_connection.getProfile()
|
---|
237 | self.domain = self.profile.getDomain()
|
---|
238 |
|
---|
239 | # initialize FrequencyOpponentModel
|
---|
240 | self.opponent_model = FrequencyOpponentModel.FrequencyOpponentModel.create().With(
|
---|
241 | newDomain=self.profile.getDomain(),
|
---|
242 | newResBid=self.profile.getReservationBid())
|
---|
243 |
|
---|
244 | profile_connection.close()
|
---|
245 |
|
---|
246 | # ActionDone informs you of an action (an offer or an accept)
|
---|
247 | # that is performed by one of the agents (including yourself).
|
---|
248 | elif isinstance(data, ActionDone):
|
---|
249 | action = cast(ActionDone, data).getAction()
|
---|
250 |
|
---|
251 | actor = action.getActor()
|
---|
252 |
|
---|
253 | if isinstance(action, Accept):
|
---|
254 | # print(str(actor).rsplit("_", 1)[0], '=>', cast(Offer, action).getBid())
|
---|
255 | agreement_bid = cast(Offer, action).getBid()
|
---|
256 | self.agreement_utility = float(
|
---|
257 | self.profile.getUtility(agreement_bid))
|
---|
258 | self.who_accepted = str(actor).rsplit("_", 1)[0]
|
---|
259 |
|
---|
260 | # ignore action if it is our action
|
---|
261 | if actor != self.me:
|
---|
262 | # obtain the name of the opponent, cutting of the position ID.
|
---|
263 | self.other = str(actor).rsplit("_", 1)[0]
|
---|
264 |
|
---|
265 | # set parameters according of saved data
|
---|
266 | if not self.is_called:
|
---|
267 | self.set_parameters(self.other)
|
---|
268 | self.is_called = True
|
---|
269 |
|
---|
270 | # process action done by opponent
|
---|
271 | self.opponent_action(action)
|
---|
272 | # YourTurn notifies you that it is your turn to act
|
---|
273 | elif isinstance(data, YourTurn):
|
---|
274 | # execute a turn
|
---|
275 | self.my_turn()
|
---|
276 |
|
---|
277 | # Finished will be send if the negotiation has ended (through agreement or deadline)
|
---|
278 | elif isinstance(data, Finished):
|
---|
279 | self.save_data()
|
---|
280 | # terminate the agent MUST BE CALLED
|
---|
281 | self.logger.log(logging.INFO, "party is terminating:")
|
---|
282 | super().terminate()
|
---|
283 | else:
|
---|
284 | self.logger.log(logging.WARNING,
|
---|
285 | "Ignoring unknown info " + str(data))
|
---|
286 |
|
---|
287 | def getCapabilities(self) -> Capabilities:
|
---|
288 | """MUST BE IMPLEMENTED
|
---|
289 | Method to indicate to the protocol what the capabilities of this agent are.
|
---|
290 | Leave it as is for the ANL 2022 competition
|
---|
291 | Returns:
|
---|
292 | Capabilities: Capabilities representation class
|
---|
293 | """
|
---|
294 | return Capabilities(
|
---|
295 | set(["SAOP"]),
|
---|
296 | set(["geniusweb.profile.utilityspace.LinearAdditive"]),
|
---|
297 | )
|
---|
298 |
|
---|
299 | def send_action(self, action: Action):
|
---|
300 | """Sends an action to the opponent(s)
|
---|
301 | Args:
|
---|
302 | action (Action): action of this agent
|
---|
303 | """
|
---|
304 | self.getConnection().send(action)
|
---|
305 |
|
---|
306 | # give a description of your agent
|
---|
307 | def getDescription(self) -> str:
|
---|
308 | """MUST BE IMPLEMENTED
|
---|
309 | Returns a description of your agent. 1 or 2 sentences.
|
---|
310 | Returns:
|
---|
311 | str: Agent description
|
---|
312 | """
|
---|
313 | return "LuckyAgent2022"
|
---|
314 |
|
---|
315 | def opponent_action(self, action):
|
---|
316 | """Process an action that was received from the opponent.
|
---|
317 | Args:
|
---|
318 | action (Action): action of opponent
|
---|
319 | """
|
---|
320 | # if it is an offer, set the last received bid
|
---|
321 | if isinstance(action, Offer):
|
---|
322 |
|
---|
323 | bid = cast(Offer, action).getBid()
|
---|
324 |
|
---|
325 | # update opponent model with bid
|
---|
326 | self.opponent_model = self.opponent_model.WithAction(
|
---|
327 | action=action, progress=self.progress)
|
---|
328 | # set bid as last received
|
---|
329 | self.last_received_bid = bid
|
---|
330 | # self.received_bids.append(bid)
|
---|
331 | self.received_bid_details.append(BidDetail(
|
---|
332 | bid, float(self.profile.getUtility(bid))))
|
---|
333 |
|
---|
334 | def my_turn(self):
|
---|
335 | """This method is called when it is our turn. It should decide upon an action
|
---|
336 | to perform and send this action to the opponent.
|
---|
337 | """
|
---|
338 | self.cal_thresholds()
|
---|
339 | self._updateUtilSpace()
|
---|
340 |
|
---|
341 | next_bid = self.find_bid()
|
---|
342 | # check if the last received offer is good enough
|
---|
343 | if self.accept_condition(self.last_received_bid, next_bid):
|
---|
344 | # if so, accept the offer
|
---|
345 | action = Accept(self.me, self.last_received_bid)
|
---|
346 | else:
|
---|
347 | # if not, find a bid to propose as counter offer
|
---|
348 | action = Offer(self.me, next_bid)
|
---|
349 | # self.my_bids.append(next_bid)
|
---|
350 | self.my_bid_details.append(
|
---|
351 | BidDetail(next_bid, float(self.profile.getUtility(next_bid))))
|
---|
352 |
|
---|
353 | # send the action
|
---|
354 | self.send_action(action)
|
---|
355 |
|
---|
356 | def _updateUtilSpace(self) -> LinearAdditive: # throws IOException
|
---|
357 | newutilspace = self.profile
|
---|
358 | if not newutilspace == self._utilspace:
|
---|
359 | self._utilspace = cast(LinearAdditive, newutilspace)
|
---|
360 | self._extendedspace = ExtendedUtilSpace(self._utilspace)
|
---|
361 | return self._utilspace
|
---|
362 |
|
---|
363 | def save_data(self):
|
---|
364 | """This method is called after the negotiation is finished. It can be used to store data
|
---|
365 | for learning capabilities. Note that no extensive calculations can be done within this method.
|
---|
366 | Taking too much time might result in your agent being killed, so use it for storage only.
|
---|
367 | """
|
---|
368 | # **************************************************
|
---|
369 |
|
---|
370 | c_data = {}
|
---|
371 | if os.path.isfile(f"{self.storage_dir}/c_data"):
|
---|
372 | # OLD
|
---|
373 | # dbfile_c = open(f"{self.storage_dir}/c_data", 'rb')
|
---|
374 | # c_data = pickle.load(dbfile_c)
|
---|
375 | # dbfile_c.close()
|
---|
376 | # NEW
|
---|
377 | with open(f"{self.storage_dir}/c_data", 'rb') as dbfile_c:
|
---|
378 | c_data = pickle.load(dbfile_c)
|
---|
379 |
|
---|
380 | if os.path.exists(f"{self.storage_dir}/c_data"):
|
---|
381 | os.remove(f"{self.storage_dir}/c_data")
|
---|
382 |
|
---|
383 | c_data[self.other] = self.condition_d
|
---|
384 | # OLD
|
---|
385 | # dbfile_c = open(f"{self.storage_dir}/c_data", 'ab')
|
---|
386 | # pickle.dump(c_data, dbfile_c)
|
---|
387 | # dbfile_c.close()
|
---|
388 | # NEW
|
---|
389 | with open(f"{self.storage_dir}/c_data", 'ab') as dbfile_c:
|
---|
390 | pickle.dump(c_data, dbfile_c)
|
---|
391 |
|
---|
392 | m_data = {}
|
---|
393 | if os.path.isfile(f"{self.storage_dir}/m_data"):
|
---|
394 | # OLD
|
---|
395 | # dbfile = open(f"{self.storage_dir}/m_data", 'rb')
|
---|
396 | # m_data = pickle.load(dbfile)
|
---|
397 | # dbfile.close()
|
---|
398 | # NEW
|
---|
399 | with open(f"{self.storage_dir}/m_data", 'rb') as dbfile:
|
---|
400 | m_data = pickle.load(dbfile)
|
---|
401 |
|
---|
402 |
|
---|
403 | if os.path.exists(f"{self.storage_dir}/m_data"):
|
---|
404 | os.remove(f"{self.storage_dir}/m_data")
|
---|
405 |
|
---|
406 | m_tuple = (self.agreement_utility, self.min, self.e)
|
---|
407 | if self.other in m_data:
|
---|
408 | m_data[self.other].append(m_tuple)
|
---|
409 | else:
|
---|
410 | m_data[self.other] = [m_tuple, ]
|
---|
411 |
|
---|
412 | # OLD
|
---|
413 | # dbfile = open(f"{self.storage_dir}/m_data", 'ab')
|
---|
414 | # # source, destination
|
---|
415 | # pickle.dump(m_data, dbfile)
|
---|
416 | # dbfile.close()
|
---|
417 | # NEW
|
---|
418 | with open(f"{self.storage_dir}/m_data", 'ab') as dbfile:
|
---|
419 | pickle.dump(m_data, dbfile)
|
---|
420 |
|
---|
421 | ###########################################################################################
|
---|
422 | ################################## Example methods below ##################################
|
---|
423 | ###########################################################################################
|
---|
424 |
|
---|
425 | def accept_condition(self, received_bid: Bid, next_bid) -> bool:
|
---|
426 | if received_bid is None:
|
---|
427 | return False
|
---|
428 |
|
---|
429 | progress = self.progress.get(time() * 1000)
|
---|
430 |
|
---|
431 | # set reservation value
|
---|
432 | if self.profile.getReservationBid() is None:
|
---|
433 | reservation = 0.0
|
---|
434 | else:
|
---|
435 | reservation = self.profile.getUtility(
|
---|
436 | self.profile.getReservationBid())
|
---|
437 |
|
---|
438 | received_bid_utility = self.profile.getUtility(received_bid)
|
---|
439 | condition1 = received_bid_utility >= self.threshold_acceptance and received_bid_utility >= reservation
|
---|
440 | condition2 = progress > 0.97 and received_bid_utility > self.min and received_bid_utility >= reservation
|
---|
441 | condition3 = self.alpha*float(received_bid_utility) + self.betta >= float(
|
---|
442 | self.profile.getUtility(next_bid)) and received_bid_utility >= reservation
|
---|
443 |
|
---|
444 | return condition1 or condition2 or condition3
|
---|
445 |
|
---|
446 | def find_bid(self) -> Bid:
|
---|
447 | """
|
---|
448 | @return next possible bid with current target utility, or null if no such
|
---|
449 | bid.
|
---|
450 | """
|
---|
451 | interval = self.threshold_high - self.threshold_low
|
---|
452 | s = interval / NUMBER_OF_GOALS
|
---|
453 |
|
---|
454 | utility_goals = []
|
---|
455 | for i in range(NUMBER_OF_GOALS):
|
---|
456 | utility_goals.append(self.threshold_low+s*i)
|
---|
457 | utility_goals.append(self.threshold_high)
|
---|
458 |
|
---|
459 | options: ImmutableList[Bid] = self._extendedspace.getBids(
|
---|
460 | Decimal(random.choice(utility_goals)))
|
---|
461 |
|
---|
462 | opponent_utilities = []
|
---|
463 | for option in options:
|
---|
464 | if self.opponent_model != None:
|
---|
465 | opp_utility = float(
|
---|
466 | self.opponent_model.getUtility(option))
|
---|
467 | if opp_utility > 0:
|
---|
468 | opponent_utilities.append(opp_utility)
|
---|
469 | else:
|
---|
470 | opponent_utilities.append(0.00001)
|
---|
471 | else:
|
---|
472 | opponent_utilities.append(0.00001)
|
---|
473 |
|
---|
474 | if options.size() == 0:
|
---|
475 | # if we can't find good bid, get max util bid....
|
---|
476 | options = self._extendedspace.getBids(self._extendedspace.getMax())
|
---|
477 | return options.get(randint(0, options.size() - 1))
|
---|
478 | # pick a random one.
|
---|
479 |
|
---|
480 | next_bid = random.choices(list(options), weights=opponent_utilities)[0]
|
---|
481 | for bid_detaile in self.received_bid_details:
|
---|
482 | if bid_detaile.getUtility() >= self.profile.getUtility(next_bid):
|
---|
483 | next_bid = bid_detaile.getBid()
|
---|
484 |
|
---|
485 | return random.choices(list(options), weights=opponent_utilities)[0]
|
---|
486 |
|
---|
487 | # ************************************************************
|
---|
488 | def f(self, t, k, e):
|
---|
489 | return k + (1-k)*(t**(1/e))
|
---|
490 |
|
---|
491 | def p(self, min1, max1, e, t):
|
---|
492 | return min1 + (1-self.f(t, 0, e))*(max1-min1)
|
---|
493 |
|
---|
494 | def cal_thresholds(self):
|
---|
495 | progress = self.progress.get(time() * 1000)
|
---|
496 | self.threshold_high = self.p(self.min+0.1, self.max, self.e, progress)
|
---|
497 | self.threshold_acceptance = self.p(
|
---|
498 | self.min+0.1, self.max, self.e, progress) - (0.1*((progress+0.0000001)))
|
---|
499 | self.threshold_low = self.p(self.min+0.1, self.max, self.e, progress) - \
|
---|
500 | (0.1*((progress+0.0000001))) * abs(math.sin(progress * 60))
|
---|
501 |
|
---|
502 | # ================================================================
|
---|
503 | def get_domain_size(self, domain: Domain):
|
---|
504 | domain_size = 1
|
---|
505 | for issue in domain.getIssues():
|
---|
506 | domain_size *= domain.getValues(issue).size()
|
---|
507 | return domain_size
|
---|
508 | # ================================================================
|
---|
509 |
|
---|
510 |
|
---|
511 | class BidDetail:
|
---|
512 | def __init__(self, bid: Bid, utility: float):
|
---|
513 | self.__bid = bid
|
---|
514 | self.__utiltiy = utility
|
---|
515 |
|
---|
516 | def getBid(self):
|
---|
517 | return self.__bid
|
---|
518 |
|
---|
519 | def getUtility(self):
|
---|
520 | return self.__utiltiy
|
---|
521 |
|
---|
522 | def __repr__(self) -> str:
|
---|
523 | return f'{self.__bid}: {self.__utiltiy}'
|
---|