1 | import json
|
---|
2 | import math
|
---|
3 | import os
|
---|
4 | from decimal import Decimal
|
---|
5 | from os.path import exists
|
---|
6 |
|
---|
7 | from geniusweb.inform.Agreements import Agreements
|
---|
8 | from geniusweb.issuevalue.ValueSet import ValueSet
|
---|
9 | from geniusweb.issuevalue.Value import Value
|
---|
10 | from geniusweb.issuevalue.DiscreteValue import DiscreteValue
|
---|
11 | from geniusweb.issuevalue.NumberValue import NumberValue
|
---|
12 |
|
---|
13 | import logging
|
---|
14 | from random import randint
|
---|
15 | import time
|
---|
16 | from typing import cast
|
---|
17 |
|
---|
18 | from geniusweb.actions.Accept import Accept
|
---|
19 | from geniusweb.actions.Action import Action
|
---|
20 | from geniusweb.actions.Offer import Offer
|
---|
21 | from geniusweb.actions.PartyId import PartyId
|
---|
22 | from geniusweb.bidspace.AllBidsList import AllBidsList
|
---|
23 | from geniusweb.inform.ActionDone import ActionDone
|
---|
24 | from geniusweb.inform.Finished import Finished
|
---|
25 | from geniusweb.inform.Inform import Inform
|
---|
26 | from geniusweb.inform.Settings import Settings
|
---|
27 | from geniusweb.inform.YourTurn import YourTurn
|
---|
28 | from geniusweb.issuevalue.Bid import Bid
|
---|
29 | from geniusweb.issuevalue.Domain import Domain
|
---|
30 | from geniusweb.party.Capabilities import Capabilities
|
---|
31 | from geniusweb.party.DefaultParty import DefaultParty
|
---|
32 | from geniusweb.profile.utilityspace.UtilitySpace import UtilitySpace
|
---|
33 | from geniusweb.profileconnection.ProfileConnectionFactory import (
|
---|
34 | ProfileConnectionFactory,
|
---|
35 | )
|
---|
36 | from geniusweb.progress.ProgressTime import ProgressTime
|
---|
37 | from geniusweb.references.Parameters import Parameters
|
---|
38 | from numpy import long
|
---|
39 | from tudelft_utilities_logging.ReportToLogger import ReportToLogger
|
---|
40 |
|
---|
41 | from .LearnedData import LearnedData
|
---|
42 | from .NegotiationData import NegotiationData
|
---|
43 | from .Pair import Pair
|
---|
44 |
|
---|
45 | # static vars
|
---|
46 | defualtAlpha: float = 10.7
|
---|
47 | # estimate opponent time - variant threshold function
|
---|
48 | tSplit: int = 40
|
---|
49 | # agent has 2 - phases - learning of the opponent and offering bids while considering opponent utility, this constant define the threshold between those two phases
|
---|
50 | tPhase: float = 0.2
|
---|
51 |
|
---|
52 |
|
---|
53 |
|
---|
54 | class CompromisingAgent(DefaultParty):
|
---|
55 | def __init__(self):
|
---|
56 | super().__init__()
|
---|
57 | self.logger: ReportToLogger = self.getReporter()
|
---|
58 | self.lastReceivedBid: Bid = None
|
---|
59 | self.me: PartyId = None
|
---|
60 | self.progress: ProgressTime = None
|
---|
61 | self.protocol: str = None
|
---|
62 | self.parameters: Parameters = None
|
---|
63 | self.utilitySpace: UtilitySpace = None
|
---|
64 | self.domain: Domain = None
|
---|
65 | self.learnedData: LearnedData = None
|
---|
66 | self.negotiationData: NegotiationData = None
|
---|
67 | self.learnedDataPath: str = None
|
---|
68 | self.negotiationDataPath: str = None
|
---|
69 | self.storage_dir: str = None
|
---|
70 |
|
---|
71 | self.opponentName: str = None
|
---|
72 |
|
---|
73 | # Expecting Lower Limit of Concession Function behavior
|
---|
74 | # The idea here that we will keep for a negotiation scenario the most frequent
|
---|
75 | # Issues - Values, afterwards, as a counter offer bid for each issue we will select the most frequent value.
|
---|
76 | self.freqMap: dict = None
|
---|
77 |
|
---|
78 | # average and standard deviation of the competition for determine "good" utility threshold
|
---|
79 | self.avgUtil: float = 0.95
|
---|
80 | self.stdUtil: float = 0.15
|
---|
81 | self.utilThreshold: float = 0.95
|
---|
82 |
|
---|
83 | self.alpha: float = defualtAlpha
|
---|
84 |
|
---|
85 | self.opCounter: list = [0] * tSplit
|
---|
86 | self.opSum: list = [0.0] * tSplit
|
---|
87 | self.opThreshold: list = [0.0] * tSplit
|
---|
88 | self.opReject: list = [0.0] * tSplit
|
---|
89 |
|
---|
90 | # Best bid for agent, exists if bid space is small enough to search in
|
---|
91 | self.MAX_SEARCHABLE_BIDSPACE: long = 50000
|
---|
92 | self.MIN_UTILITY: float = 0.6
|
---|
93 | self.optimalBid: Bid = None
|
---|
94 | self.bestOfferBid: Bid = None
|
---|
95 | self.allBidList: AllBidsList = None
|
---|
96 |
|
---|
97 | self.lastOfferBid = None # our last offer to the opponent
|
---|
98 |
|
---|
99 | def notifyChange(self, data: Inform):
|
---|
100 | """
|
---|
101 | Args:
|
---|
102 | data (Inform): Contains either a request for action or information.
|
---|
103 | """
|
---|
104 | try:
|
---|
105 | # a Settings message is the first message that will be send to your
|
---|
106 | # agent containing all the information about the negotiation session.
|
---|
107 | if isinstance(data, Settings):
|
---|
108 | self.settingsFunction(cast(Settings, data))
|
---|
109 |
|
---|
110 | # ActionDone informs you of an action (an offer or an accept)
|
---|
111 | # that is performed by one of the agents (including yourself).
|
---|
112 | elif isinstance(data, ActionDone):
|
---|
113 | self.actionDoneFunction(cast(ActionDone, data))
|
---|
114 |
|
---|
115 | # YourTurn notifies you that it is your turn to act
|
---|
116 | elif isinstance(data, YourTurn):
|
---|
117 | # execute a turn
|
---|
118 | self.myTurn()
|
---|
119 |
|
---|
120 | # Finished will be send if the negotiation has ended (through agreement or deadline)
|
---|
121 | elif isinstance(data, Finished):
|
---|
122 | self.finishedFunction(cast(Finished, data))
|
---|
123 |
|
---|
124 | else:
|
---|
125 | self.logger.log(logging.WARNING, "Ignoring unknown info " + str(data))
|
---|
126 |
|
---|
127 | except:
|
---|
128 | self.logger.log(logging.ERROR, "error notifyChange")
|
---|
129 |
|
---|
130 | def getDescription(self) -> str:
|
---|
131 | """Returns a description of your agent.
|
---|
132 |
|
---|
133 | Returns:
|
---|
134 | str: Agent description
|
---|
135 | """
|
---|
136 | return "This is party of ANL 2022. It can handle the Learn protocol and learns utility function and threshold of the opponent."
|
---|
137 |
|
---|
138 | def getCapabilities(self) -> Capabilities:
|
---|
139 | """
|
---|
140 | Method to indicate to the protocol what the capabilities of this agent are.
|
---|
141 | Leave it as is for the ANL 2022 competition
|
---|
142 |
|
---|
143 | Returns:
|
---|
144 | Capabilities: Capabilities representation class
|
---|
145 | """
|
---|
146 | return Capabilities(
|
---|
147 | set(["SAOP"]),
|
---|
148 | set(["geniusweb.profile.utilityspace.LinearAdditive"]),
|
---|
149 | )
|
---|
150 |
|
---|
151 | def finishedFunction(self, data: Finished):
|
---|
152 | # object also contains the final agreement( if any).
|
---|
153 | agreements: Agreements = data.getAgreements()
|
---|
154 | self.processAgreements(agreements)
|
---|
155 |
|
---|
156 | # Write the negotiation data that we collected to the path provided.
|
---|
157 | if not (self.negotiationDataPath == None or self.negotiationData == None):
|
---|
158 | try:
|
---|
159 | with open(self.negotiationDataPath, "w") as f:
|
---|
160 | # w means overwritten
|
---|
161 | json.dump(self.negotiationData.__dict__, default=lambda o: o.__dict__, indent=5, fp=f)
|
---|
162 |
|
---|
163 |
|
---|
164 | except:
|
---|
165 | self.logger.log(logging.ERROR, "Failed to write negotiation data to disk")
|
---|
166 |
|
---|
167 | # Write the learned data to the path provided.
|
---|
168 | if not (self.learnedDataPath == None or self.learnedData == None):
|
---|
169 | try:
|
---|
170 | with open(self.learnedDataPath, "w") as f:
|
---|
171 | # w means overwritten
|
---|
172 | json.dump(self.learnedData.__dict__, default=lambda o: o.__dict__, indent=9, fp=f)
|
---|
173 |
|
---|
174 |
|
---|
175 | except:
|
---|
176 | self.logger.log(logging.ERROR, "Failed to learned data to disk")
|
---|
177 |
|
---|
178 | self.logger.log(logging.INFO, "party is terminating:")
|
---|
179 | super().terminate()
|
---|
180 |
|
---|
181 | def actionDoneFunction(self, data: ActionDone):
|
---|
182 | # The info object is an action that is performed by an agent.
|
---|
183 | action: Action = data.getAction()
|
---|
184 | actor = action.getActor()
|
---|
185 |
|
---|
186 | # Check if this is not our own action
|
---|
187 | if self.me is not None and not (self.me == actor):
|
---|
188 | # Check if we already know who we are playing against.
|
---|
189 | if self.opponentName == None:
|
---|
190 | # The part behind the last _ is always changing, so we must cut it off.
|
---|
191 | self.opponentName = str(actor).rsplit("_", 1)[0]
|
---|
192 |
|
---|
193 | # path depend on opponent name
|
---|
194 | self.negotiationDataPath = self.getPath("negotiationData", self.opponentName)
|
---|
195 | self.learnedDataPath = self.getPath("learnedData", self.opponentName)
|
---|
196 |
|
---|
197 | # update and load learnedData
|
---|
198 | self.updateAndLoadLearnedData()
|
---|
199 |
|
---|
200 | # Add name of the opponent to the negotiation data
|
---|
201 | self.negotiationData.setOpponentName(self.opponentName)
|
---|
202 |
|
---|
203 | # avg opponent offer utility
|
---|
204 | self.opThreshold = self.learnedData.getSmoothThresholdOverTime() \
|
---|
205 | if self.learnedData != None else None
|
---|
206 | if not (self.opThreshold == None):
|
---|
207 | for i in range(tSplit):
|
---|
208 | self.opThreshold[i] = self.opThreshold[i] if self.opThreshold[i] > 0 else self.opThreshold[
|
---|
209 | i - 1]
|
---|
210 |
|
---|
211 | # max offer the opponent reject
|
---|
212 | self.opReject = self.learnedData.getSmoothRejectOverTime() \
|
---|
213 | if self.learnedData != None else None
|
---|
214 | if not (self.opReject == None):
|
---|
215 | for i in range(tSplit):
|
---|
216 | self.opReject[i] = self.opReject[i] if self.opReject[i] > 0 else self.opReject[
|
---|
217 | i - 1]
|
---|
218 |
|
---|
219 | # decay rate of threshold function
|
---|
220 | self.alpha = self.learnedData.getOpponentAlpha() if self.learnedData != None else 0.0
|
---|
221 | self.alpha = self.alpha if self.alpha > 0.0 else defualtAlpha
|
---|
222 |
|
---|
223 | # Process the action of the opponent.
|
---|
224 | self.processAction(action)
|
---|
225 |
|
---|
226 | def settingsFunction(self, data: Settings):
|
---|
227 | # info is a Settings object that is passed at the start of a negotiation
|
---|
228 | settings: Settings = data
|
---|
229 |
|
---|
230 | # ID of my agent
|
---|
231 | self.me = settings.getID()
|
---|
232 |
|
---|
233 | # The progress object keeps track of the deadline
|
---|
234 | self.progress = settings.getProgress()
|
---|
235 |
|
---|
236 | # Protocol that is initiate for the agent
|
---|
237 | self.protocol = str(settings.getProtocol().getURI().getPath())
|
---|
238 |
|
---|
239 | # Parameters for the agent (can be passed through the GeniusWeb GUI, or a JSON-file)
|
---|
240 | self.parameters = settings.getParameters()
|
---|
241 |
|
---|
242 | self.storage_dir = self.parameters.get("storage_dir")
|
---|
243 |
|
---|
244 | # We are in the negotiation step.
|
---|
245 | # Create a new NegotiationData object to store information on this negotiation.
|
---|
246 | # See 'NegotiationData.py'.
|
---|
247 |
|
---|
248 | self.negotiationData = NegotiationData()
|
---|
249 |
|
---|
250 | # Obtain our utility space, i.e.the problem we are negotiating and our
|
---|
251 | # preferences over it.
|
---|
252 | try:
|
---|
253 | # the profile contains the preferences of the agent over the domain
|
---|
254 | profile_connection = ProfileConnectionFactory.create(data.getProfile().getURI(), self.getReporter())
|
---|
255 | self.domain = profile_connection.getProfile().getDomain()
|
---|
256 |
|
---|
257 | # Create a Issues-Values frequency map
|
---|
258 | if self.freqMap == None:
|
---|
259 | # Map wasn't created before, create a new instance now
|
---|
260 | self.freqMap = {}
|
---|
261 | else:
|
---|
262 | # Map was created before, but this is a new negotiation scenario, clear the old map.
|
---|
263 | self.freqMap.clear()
|
---|
264 |
|
---|
265 | # Obtain all of the issues in the current negotiation domain
|
---|
266 | issues: set = self.domain.getIssues()
|
---|
267 | for s in issues:
|
---|
268 | # create new list of all the values for
|
---|
269 | p: Pair = Pair()
|
---|
270 | p.vList = {}
|
---|
271 |
|
---|
272 | # gather type of issue based on the first element
|
---|
273 | vs: ValueSet = self.domain.getValues(s)
|
---|
274 | if isinstance(vs.get(0), DiscreteValue):
|
---|
275 | p.type = 0
|
---|
276 | elif isinstance(vs.get(0), NumberValue):
|
---|
277 | p.type = 1
|
---|
278 |
|
---|
279 | # Obtain all of the values for an issue "s"
|
---|
280 | for v in vs:
|
---|
281 | # Add a new entry in the frequency map for each(s, v, typeof(v))
|
---|
282 | vStr: str = self.valueToStr(v, p)
|
---|
283 | p.vList[vStr] = 0
|
---|
284 |
|
---|
285 | self.freqMap[s] = p
|
---|
286 |
|
---|
287 | except:
|
---|
288 | self.logger.log(logging.ERROR, "error settingsFunction")
|
---|
289 |
|
---|
290 | # self.utilitySpace = cast(profile_connection.getProfile(), UtilitySpace)
|
---|
291 | self.utilitySpace = profile_connection.getProfile()
|
---|
292 | profile_connection.close()
|
---|
293 |
|
---|
294 | self.allBidList = AllBidsList(self.domain)
|
---|
295 |
|
---|
296 | # Attempt to find the optimal bid in a search-able bid space, if bid space size
|
---|
297 | # is small / equal to MAX_SEARCHABLE_BIDSPACE
|
---|
298 | if self.allBidList.size() <= self.MAX_SEARCHABLE_BIDSPACE:
|
---|
299 | mx_util: Decimal = Decimal(0)
|
---|
300 | for i in range(self.allBidList.size()):
|
---|
301 | b: Bid = self.allBidList.get(i)
|
---|
302 | canidate: Decimal = self.utilitySpace.getUtility(b)
|
---|
303 | if canidate > mx_util:
|
---|
304 | mx_util = canidate
|
---|
305 | self.optimalBid = b
|
---|
306 |
|
---|
307 | else:
|
---|
308 | mx_util: Decimal = Decimal(0)
|
---|
309 | # Iterate randomly through list of bids until we find a good bid
|
---|
310 | for attempt in range(self.MAX_SEARCHABLE_BIDSPACE.intValue()):
|
---|
311 | i: long = randint(0, self.allBidList.size())
|
---|
312 | b: Bid = self.allBidList.get(i)
|
---|
313 | canidate: Decimal = self.utilitySpace.getUtility(b)
|
---|
314 | if canidate > mx_util:
|
---|
315 | mx_util = canidate
|
---|
316 | self.optimalBid = b
|
---|
317 |
|
---|
318 | def isNearNegotiationEnd(self):
|
---|
319 | return 0 if self.progress.get(int(time.time() * 1000)) < tPhase else 1
|
---|
320 |
|
---|
321 | def processAction(self, action: Action):
|
---|
322 | """Processes an Action performed by the opponent."""
|
---|
323 | if isinstance(action, Offer):
|
---|
324 | # If the action was an offer: Obtain the bid
|
---|
325 | self.lastReceivedBid = cast(Offer, action).getBid()
|
---|
326 | self.updateFreqMap(self.lastReceivedBid)
|
---|
327 |
|
---|
328 | # add it's value to our negotiation data.
|
---|
329 | utilVal: float = float(self.utilitySpace.getUtility(self.lastReceivedBid))
|
---|
330 | self.negotiationData.addBidUtil(utilVal)
|
---|
331 |
|
---|
332 | def processAgreements(self, agreements: Agreements):
|
---|
333 |
|
---|
334 | """ This method is called when the negotiation has finished. It can process the"
|
---|
335 | final agreement.
|
---|
336 | """
|
---|
337 | # Check if we reached an agreement (walking away or passing the deadline
|
---|
338 | # results in no agreement)
|
---|
339 | if agreements.getMap() != None and not (agreements.getMap() == {}):
|
---|
340 | # Get the bid that is agreed upon and add it's value to our negotiation data
|
---|
341 | agreement: Bid = list(agreements.getMap().values())[0]
|
---|
342 | self.negotiationData.addAgreementUtil(float(self.utilitySpace.getUtility(agreement)))
|
---|
343 | self.negotiationData.setOpponentUtil(self.calcOpValue(agreement))
|
---|
344 |
|
---|
345 | # negotiation failed
|
---|
346 | else:
|
---|
347 | if not (self.bestOfferBid == None):
|
---|
348 | self.negotiationData.addAgreementUtil(float(self.utilitySpace.getUtility(self.bestOfferBid)))
|
---|
349 |
|
---|
350 | # update opponent reject list
|
---|
351 | if self.lastOfferBid != None:
|
---|
352 | self.negotiationData.addRejectUtil(tSplit - 1, self.calcOpValue(self.lastOfferBid))
|
---|
353 |
|
---|
354 | # update the opponent offers map, regardless of achieving agreement or not
|
---|
355 | try:
|
---|
356 | self.negotiationData.updateOpponentOffers(self.opSum, self.opCounter);
|
---|
357 | except:
|
---|
358 | self.logger.log(logging.ERROR, "error processAgreements")
|
---|
359 |
|
---|
360 | # send our next offer
|
---|
361 | def myTurn(self):
|
---|
362 | action: Action = None
|
---|
363 |
|
---|
364 | # save average of the last avgSplit offers (only when frequency table is stabilized)
|
---|
365 | if self.isNearNegotiationEnd() > 0:
|
---|
366 | index: int = (int)((tSplit - 1) / (1 - tPhase) * (self.progress.get(int(time.time() * 1000)) - tPhase))
|
---|
367 |
|
---|
368 | if self.lastReceivedBid != None:
|
---|
369 | self.opSum[index] += self.calcOpValue(self.lastReceivedBid)
|
---|
370 | self.opCounter[index] += 1
|
---|
371 |
|
---|
372 | if self.lastOfferBid != None:
|
---|
373 | self.negotiationData.addRejectUtil(index, self.calcOpValue(self.lastOfferBid))
|
---|
374 |
|
---|
375 | # evaluate the offer and accept or give counter-offer
|
---|
376 | if self.isGood(self.lastReceivedBid):
|
---|
377 | # If the last received bid is good: create Accept action
|
---|
378 | action = Accept(self.me, self.lastReceivedBid)
|
---|
379 | else:
|
---|
380 | # there are 3 phases in the negotiation process:
|
---|
381 | # 1. Send random bids that considered to be GOOD for our agent
|
---|
382 | # 2. Send random bids that considered to be GOOD for both of the agents
|
---|
383 | bid: Bid = None
|
---|
384 |
|
---|
385 | if self.bestOfferBid == None:
|
---|
386 | self.bestOfferBid = self.lastReceivedBid
|
---|
387 | elif self.lastReceivedBid != None and self.utilitySpace.getUtility(self.lastReceivedBid) > self.utilitySpace \
|
---|
388 | .getUtility(self.bestOfferBid):
|
---|
389 | self.bestOfferBid = self.lastReceivedBid
|
---|
390 |
|
---|
391 | isNearNegotiationEnd = self.isNearNegotiationEnd()
|
---|
392 | if isNearNegotiationEnd == 0:
|
---|
393 | attempt = 0
|
---|
394 | while attempt < 1000 and not self.isGood(bid):
|
---|
395 | attempt += 1
|
---|
396 | i: long = randint(0, self.allBidList.size())
|
---|
397 | bid = self.allBidList.get(i)
|
---|
398 |
|
---|
399 | bid = bid if (self.isGood(
|
---|
400 | bid)) else self.optimalBid # if the last bid isn't good, offer (default) the optimal bid
|
---|
401 |
|
---|
402 | elif isNearNegotiationEnd == 1:
|
---|
403 | if self.progress.get(int(time.time() * 1000)) > 0.95:
|
---|
404 | maxOpponentUtility: float = 0.0
|
---|
405 | maxBid: Bid = None
|
---|
406 | i = 0
|
---|
407 | while i < 10000 and self.progress.get(int(time.time() * 1000)) < 0.99:
|
---|
408 | i: long = randint(0, self.allBidList.size())
|
---|
409 | bid = self.allBidList.get(i)
|
---|
410 | if self.isGood(bid) and self.isOpGood(bid):
|
---|
411 | opValue = self.calcOpValue(bid)
|
---|
412 | if opValue > maxOpponentUtility:
|
---|
413 | maxOpponentUtility = opValue
|
---|
414 | maxBid = bid
|
---|
415 | i += 1
|
---|
416 | bid = maxBid
|
---|
417 | else:
|
---|
418 | # look for bid with max utility for opponent
|
---|
419 | maxOpponentUtility: float = 0.0
|
---|
420 | maxBid: Bid = None
|
---|
421 | for i in range(2000):
|
---|
422 | i: long = randint(0, self.allBidList.size())
|
---|
423 | bid = self.allBidList.get(i)
|
---|
424 | if self.isGood(bid) and self.isOpGood(bid):
|
---|
425 | opValue = self.calcOpValue(bid)
|
---|
426 | if opValue > maxOpponentUtility:
|
---|
427 | maxOpponentUtility = opValue
|
---|
428 | maxBid = bid
|
---|
429 | bid = maxBid
|
---|
430 |
|
---|
431 | bid = bid if self.isGood(
|
---|
432 | bid) else self.optimalBid # if the last bid isn't good, offer (default) the optimal bid
|
---|
433 | bid = self.bestOfferBid if (self.progress.get(int(time.time() * 1000)) > 0.99) else bid
|
---|
434 |
|
---|
435 |
|
---|
436 | # Create offer action
|
---|
437 | action = Offer(self.me, bid)
|
---|
438 | self.lastOfferBid = bid
|
---|
439 |
|
---|
440 | # Send action
|
---|
441 | self.getConnection().send(action)
|
---|
442 |
|
---|
443 | def isGood(self, bid: Bid):
|
---|
444 | """ The method checks if a bid is good.
|
---|
445 | param bid the bid to check
|
---|
446 | return true iff bid is good for us.
|
---|
447 | """
|
---|
448 | if bid == None:
|
---|
449 | return False
|
---|
450 | maxVlue: float = 0.95 * float(
|
---|
451 | self.utilitySpace.getUtility(self.optimalBid)) if not self.optimalBid == None else 0.95
|
---|
452 | avgMaxUtility: float = self.learnedData.getAvgMaxUtility() \
|
---|
453 | if self.learnedData != None \
|
---|
454 | else self.avgUtil
|
---|
455 |
|
---|
456 | self.utilThreshold = maxVlue \
|
---|
457 | - (maxVlue - 0.55 * self.avgUtil - 0.4 * avgMaxUtility + 0.5 * pow(self.stdUtil, 2)) \
|
---|
458 | * (math.exp(self.alpha * self.progress.get(int(time.time() * 1000))) - 1) \
|
---|
459 | / (math.exp(self.alpha) - 1)
|
---|
460 |
|
---|
461 | if (self.utilThreshold < self.MIN_UTILITY):
|
---|
462 | self.utilThreshold = self.MIN_UTILITY
|
---|
463 |
|
---|
464 | return float(self.utilitySpace.getUtility(bid)) >= self.utilThreshold
|
---|
465 |
|
---|
466 | def calcOpValue(self, bid: Bid):
|
---|
467 | value: float = 0
|
---|
468 |
|
---|
469 | issues = bid.getIssues()
|
---|
470 | valUtil: list = [0] * len(issues)
|
---|
471 | issWeght: list = [0] * len(issues)
|
---|
472 | k: int = 0 # index
|
---|
473 |
|
---|
474 | for s in issues:
|
---|
475 | p: Pair = self.freqMap[s]
|
---|
476 | v: Value = bid.getValue(s)
|
---|
477 | vs: str = self.valueToStr(v, p)
|
---|
478 |
|
---|
479 | # calculate utility of value (in the issue)
|
---|
480 | sumOfValues: int = 0
|
---|
481 | maxValue: int = 1
|
---|
482 | for vString in p.vList.keys():
|
---|
483 | sumOfValues += p.vList[vString]
|
---|
484 | maxValue = max(maxValue, p.vList[vString])
|
---|
485 |
|
---|
486 | # calculate estimated utility of the issuevalue
|
---|
487 | valUtil[k] = p.vList.get(vs) / maxValue
|
---|
488 |
|
---|
489 | # calculate the inverse std deviation of the array
|
---|
490 | mean: float = sumOfValues / len(p.vList)
|
---|
491 | for vString in p.vList.keys():
|
---|
492 | issWeght[k] += pow(p.vList.get(vString) - mean, 2)
|
---|
493 | issWeght[k] = 1.0 / math.sqrt((issWeght[k] + 0.1) / len(p.vList))
|
---|
494 |
|
---|
495 | k += 1
|
---|
496 |
|
---|
497 | sumOfWght: float = 0
|
---|
498 | for k in range(len(issues)):
|
---|
499 | value += valUtil[k] * issWeght[k]
|
---|
500 | sumOfWght += issWeght[k]
|
---|
501 |
|
---|
502 | return value / sumOfWght
|
---|
503 |
|
---|
504 | def isOpGood(self, bid: Bid):
|
---|
505 | if bid == None:
|
---|
506 | return False
|
---|
507 |
|
---|
508 | value: float = self.calcOpValue(bid)
|
---|
509 | index: int = int(((tSplit - 1) / (1 - tPhase) * (self.progress.get(int(
|
---|
510 | time.time() * 1000)) - tPhase)))
|
---|
511 | # change
|
---|
512 | opThreshold: float = max(max(2 * self.opThreshold[index] - 1, self.opReject[index]),
|
---|
513 | 0.2) if self.opThreshold != None and self.opReject != None else 0.6
|
---|
514 | return value > opThreshold
|
---|
515 |
|
---|
516 | def updateFreqMap(self, bid: Bid):
|
---|
517 | if not (bid == None):
|
---|
518 | issues = bid.getIssues()
|
---|
519 |
|
---|
520 | for s in issues:
|
---|
521 | p: Pair = self.freqMap.get(s)
|
---|
522 | v: Value = bid.getValue(s)
|
---|
523 |
|
---|
524 | vs: str = self.valueToStr(v, p)
|
---|
525 | p.vList[vs] = (p.vList.get(vs) + 1)
|
---|
526 |
|
---|
527 | def valueToStr(self, v: Value, p: Pair):
|
---|
528 | v_str: str = ""
|
---|
529 | if p.type == 0:
|
---|
530 | v_str = cast(DiscreteValue, v).getValue()
|
---|
531 | elif p.type == 1:
|
---|
532 | v_str = cast(NumberValue, v).getValue()
|
---|
533 |
|
---|
534 | if v_str == "":
|
---|
535 | print("Warning: Value wasn't found")
|
---|
536 | return v_str
|
---|
537 |
|
---|
538 | def getPath(self, dataType: str, opponentName: str):
|
---|
539 | return os.path.join(self.storage_dir, dataType + "_" + opponentName + ".json")
|
---|
540 |
|
---|
541 | def updateAndLoadLearnedData(self):
|
---|
542 | # we didn't meet this opponent before
|
---|
543 | if exists(self.negotiationDataPath):
|
---|
544 | try:
|
---|
545 | # Load the negotiation data object of a previous negotiation
|
---|
546 | with open(self.negotiationDataPath, "r") as f:
|
---|
547 | negotiationData: NegotiationData = NegotiationData()
|
---|
548 | negotiationData.encode(list(json.load(f).values()))
|
---|
549 |
|
---|
550 | except:
|
---|
551 | self.logger.log(logging.ERROR, "Negotiation data does not exist")
|
---|
552 |
|
---|
553 | if exists(self.learnedDataPath):
|
---|
554 | try:
|
---|
555 | # Load the negotiation data object of a previous negotiation
|
---|
556 | with open(self.learnedDataPath, "r") as f:
|
---|
557 | self.learnedData = LearnedData()
|
---|
558 | self.learnedData.encode(list(json.load(f).values()))
|
---|
559 |
|
---|
560 | except:
|
---|
561 | self.logger.log(logging.ERROR, "learned data does not exist")
|
---|
562 |
|
---|
563 | else:
|
---|
564 | self.learnedData = LearnedData()
|
---|
565 |
|
---|
566 | # Process the negotiation data in our learned Data
|
---|
567 | self.learnedData.update(negotiationData)
|
---|
568 | self.avgUtil = self.learnedData.getAvgUtility()
|
---|
569 | self.stdUtil = self.learnedData.getStdUtility()
|
---|