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