source: ANL2022/Pinar_Agent/utils/Pinar_Agent_Brain.py

Last change on this file was 75, checked in by wouter, 21 months ago

#6 added ANAC2022 parties
File size: 17.4 KB
Line 
1import json
2import random
3import pandas as pd
4import lightgbm as lgb
5
6from geniusweb.bidspace.AllBidsList import AllBidsList
7from geniusweb.issuevalue.Bid import Bid
8
9
10class Pinar_Agent_Brain:
11 def __init__(self):
12
13 self.acceptance_condition = 0
14 self.my_offered_number_of_time_from_ai = 0
15 self.sorted_bids_agent_that_greater_than_065_df = pd.DataFrame()
16 self.sorted_bids_agent_that_greater_than_065 = []
17
18 self.reservationBid_utility = float(0)
19 self.eva_util_val_acc_to_lgb_m_with_max_bids_for_agent = []
20 self.sorted_bids_agent_df = None
21 self.reservationBid: Bid = None
22 self.sorted_bids_agent = None
23 self.sorted_bids_agent_that_greater_than_goal_of_utility = []
24 self.all_bid_list = None
25
26 self.param = None
27
28 self.lgb_model = None
29
30 self.X = pd.DataFrame()
31 self.Y = pd.DataFrame()
32
33 self.domain = None
34 self.profile = None
35 self.issue_name_list = None
36 self.temEnumDict = None
37
38 self.offers = []
39 self.offers_unique = []
40 self.offers_unique_sorted = None
41
42 self.number_of_bid_greater_than95 = 0
43 self.percentage_of_greater_than95 = 0
44
45 self.number_of_bid_greater_than85 = 0
46 self.percentage_of_greater_than85 = 0
47
48 self.goal_of_utility = 0.80
49 self.number_of_goal_of_utility = None
50
51 @staticmethod
52 def get_goal_of_negoation_utility(x):
53 if 0 <= x <= 0.05:
54 a = float(-57.57067183) * float(x) * float(x)
55 b = float(x) * float(7.50261378)
56 c = float(1.59499339)
57 d = a + b + c
58 return float(d / 2)
59 elif x > 0.05:
60 return float(0.94)
61 return float(0.80)
62
63 def keep_opponent_offer_in_a_list(self, bid: Bid, progress_time: float):
64 # keep track of all bids received
65 self.offers.append(bid)
66
67 if bid not in self.offers_unique:
68 self.offers_unique.append(bid)
69 if progress_time >= 0.9:
70 self.offers_unique_sorted = sorted(self.offers_unique, key=lambda x: self.profile.getUtility(x),
71 reverse=True)
72
73 def add_opponent_offer_to_self_x_and_self_y(self, bid, progress_time):
74 bid_value_array = self.get_bid_value_array_for_data_frame_usage(bid)
75 df = pd.DataFrame(bid_value_array)
76 df = self.enumerate(df)
77 self.X = pd.concat([self.X, df])
78 if progress_time < 0.81:
79 val = (float(0.99) - (float(0.14) * (float(progress_time))))
80 """Y tarafına öyle bir değişken atamalıyım ki adamın utilitisi olmalı (kendi utilitime göre olsa daha mantıklı olabilir gibi şimdilik)"""
81 new = pd.DataFrame([val])
82 self.Y = pd.concat([self.Y, new])
83
84 def fill_domain_and_profile(self, domain, profile):
85 self.domain = domain
86 self.profile = profile
87 self.reservationBid = self.profile.getReservationBid()
88 if self.reservationBid is not None:
89 self.reservationBid_utility = self.profile.getUtility(self.reservationBid)
90 self.issue_name_list = self.domain.getIssues()
91 self.X = pd.DataFrame()
92 self.Y = pd.DataFrame()
93 self.temEnumDict = self.enumerate_enum_dict()
94 self.all_bid_list = AllBidsList(domain)
95
96 self.sorted_bids_agent = sorted(self.all_bid_list,
97 key=lambda x: self.profile.getUtility(x),
98 reverse=True)
99 self.calculate_percantage_and_number()
100 self.add_agent_first_n_bid_to_machine_learning_with_low_utility(self.sorted_bids_agent)
101
102 def calculate_percantage_and_number(self):
103 numb_95 = 0
104 numb_85 = 0
105 for i in self.sorted_bids_agent:
106 utility = float(self.profile.getUtility(i))
107 if utility > float(0.95):
108 numb_95 = numb_95 + 1
109 if utility > float(0.85):
110 numb_85 = numb_85 + 1
111 else:
112 break
113 self.number_of_bid_greater_than95 = numb_95
114 self.number_of_bid_greater_than85 = numb_85
115
116 self.percentage_of_greater_than95 = float(self.number_of_bid_greater_than95) / float(
117 len(self.sorted_bids_agent))
118 self.percentage_of_greater_than85 = float(self.number_of_bid_greater_than85) / float(
119 len(self.sorted_bids_agent))
120
121 self.goal_of_utility = self.get_goal_of_negoation_utility(float(self.percentage_of_greater_than85)) + float(
122 0.01)
123 numb_goal_util = 0
124 self.sorted_bids_agent_df = pd.DataFrame()
125 self.sorted_bids_agent_that_greater_than_065_df = pd.DataFrame()
126 for i in self.sorted_bids_agent:
127 utility = float(self.profile.getUtility(i))
128 if utility > float(self.goal_of_utility):
129 numb_goal_util = numb_goal_util + 1
130 if utility > (float(self.goal_of_utility) - float(0.1)):
131 self.sorted_bids_agent_that_greater_than_goal_of_utility.append(i)
132 df_temp = pd.DataFrame(self.get_bid_value_array_for_data_frame_usage(i))
133 df_temp = self.enumerate(df_temp)
134 self.sorted_bids_agent_df = pd.concat([self.sorted_bids_agent_df, df_temp])
135 if utility > 0.65:
136 self.sorted_bids_agent_that_greater_than_065.append(i)
137 df_temp = pd.DataFrame(self.get_bid_value_array_for_data_frame_usage(i))
138 df_temp = self.enumerate(df_temp)
139 self.sorted_bids_agent_that_greater_than_065_df = pd.concat(
140 [self.sorted_bids_agent_that_greater_than_065_df, df_temp])
141 else:
142 break
143 self.number_of_goal_of_utility = numb_goal_util
144
145 def evaluate_opponent_utility_for_all_my_important_bid(self, progress_time):
146 self.eva_util_val_acc_to_lgb_m_with_max_bids_for_agent = []
147 self.my_offered_number_of_time_from_ai = 0
148 util_of_opponent = self.lgb_model.predict(self.sorted_bids_agent_that_greater_than_065_df)
149
150 for index, i in enumerate(self.sorted_bids_agent_that_greater_than_065):
151 util = float(self.profile.getUtility(i))
152 if float(self.reservationBid_utility) <= util \
153 and (((float(0.93) - (
154 (float(0.95) - (self.goal_of_utility - float(0.18))) * float(progress_time))) < util)
155 and float(0.40) < util_of_opponent[index] < util - float(0.10)):
156 self.eva_util_val_acc_to_lgb_m_with_max_bids_for_agent.append(i)
157
158 def evaluate_data_according_to_lig_gbm(self, progress_time):
159 length = len(self.offers_unique)
160 if length >= 1 and (length % 2) == 0:
161 self.train_machine_learning_model()
162 self.evaluate_opponent_utility_for_all_my_important_bid(progress_time)
163
164 def train_machine_learning_model(self):
165 issue_list = []
166 for issue in self.domain.getIssues():
167 issue_list.append(issue)
168 for col in issue_list:
169 self.X[col] = self.X[col].astype('int')
170 self.Y = self.Y.astype('float')
171 train_data = lgb.Dataset(self.X, label=self.Y, feature_name=issue_list)
172 if self.param is None:
173 self.param = {
174 'objective': 'cross_entropy',
175 'learning_rate': 0.01,
176 'force_row_wise': True,
177 'feature_fraction': 1,
178 'max_depth': 3,
179 'num_leaves': 4,
180 'boosting': 'gbdt',
181 'min_data': 1,
182 'verbose': -1
183 }
184 self.lgb_model = lgb.train(self.param, train_data)
185
186 def call_model_lgb(self, bid):
187 if self.lgb_model:
188 prediction = self.lgb_model.predict(self._bid_for_model_prediction_to_df(bid))
189 return float(prediction[0])
190 else:
191 return float(1)
192
193 def get_bid_value_array_for_data_frame_usage(self, bid):
194 bid_value_array = {}
195 for issue in self.issue_name_list:
196 bid_value_array[issue] = [bid.getValue(issue)]
197 return bid_value_array
198
199 def _bid_for_model_prediction_to_df(self, bid):
200 df_temp = pd.DataFrame(self.get_bid_value_array_for_data_frame_usage(bid))
201 df_temp = self.enumerate(df_temp)
202 return df_temp
203
204 def enumerate_enum_dict(self):
205 issue_enums_dict = {}
206 for issue in self.domain.getIssues():
207 temp_enums = dict((y, x) for x, y in enumerate(set(self.domain.getIssuesValues()[issue])))
208 issue_enums_dict[issue] = temp_enums
209 return issue_enums_dict
210
211 def enumerate(self, df):
212 for issue in self.domain.getIssues():
213 df[issue] = df[issue].map(self.temEnumDict[issue])
214 return df
215
216 def model_feature_importance(self):
217 if self.lgb_model is not None:
218 df = pd.DataFrame({'Value': self.lgb_model.feature_importance(), 'Feature': self.X.columns})
219 result = df.to_json(orient="split")
220 parsed = json.loads(result)
221 return parsed
222 return ""
223
224 def util_add_agent_first_n_bid_to_machine_learning_with_low_utility(self, bid, ratio):
225 bid_value_array = self.get_bid_value_array_for_data_frame_usage(bid)
226 df = pd.DataFrame(bid_value_array)
227 df = self.enumerate(df)
228 self.X = pd.concat([self.X, df])
229 util = float(float(0.2) + (float(ratio) * float(0.35)))
230 new = pd.DataFrame([util])
231
232 self.Y = pd.concat([self.Y, new])
233
234 def add_agent_first_n_bid_to_machine_learning_with_low_utility(self, sorted_bids_agent):
235
236 if self.number_of_goal_of_utility > 150:
237 bid_number = 40
238 elif self.number_of_goal_of_utility > 100:
239 bid_number = int(float(self.number_of_goal_of_utility) / float(3.4))
240 elif self.number_of_goal_of_utility > 80:
241 bid_number = int(float(self.number_of_goal_of_utility) / float(3.1))
242 elif self.number_of_goal_of_utility > 50:
243 bid_number = int(float(self.number_of_goal_of_utility) / float(3))
244 elif self.number_of_goal_of_utility > 30:
245 bid_number = 9
246 elif self.number_of_goal_of_utility > 18:
247 bid_number = 7
248 elif 16 > self.number_of_goal_of_utility > 8:
249 bid_number = int(float(self.number_of_goal_of_utility) / float(2))
250 else:
251 bid_number = 4
252 for i in range(0, bid_number + 1):
253 bid = sorted_bids_agent[i]
254 self.util_add_agent_first_n_bid_to_machine_learning_with_low_utility(bid, float(float(i) / float(bid_number)))
255
256 def is_acceptable(self, bid: Bid, progress):
257 util = float(self.profile.getUtility(bid))
258 if util >= float(self.reservationBid_utility):
259 if util >= 0.94:
260 self.acceptance_condition = 1
261 return True
262 elif util >= 0.91 and 0.76 > float(self.call_model_lgb(bid)) > 0.6:
263 self.acceptance_condition = 2
264 return True
265 elif float(0.85) >= float(progress) > 0.82 and util > self.goal_of_utility - float(0.1) and util - float(0.28) > float(self.call_model_lgb(bid)):
266 self.acceptance_condition = 3
267 return True
268 elif float(0.94) >= float(progress) > 0.85 and util > self.goal_of_utility - float(0.14) and util - float(0.23) > float(self.call_model_lgb(bid)):
269 self.acceptance_condition = 4
270 return True
271 elif float(1.0) >= float(progress) > 0.93 and util > self.goal_of_utility - float(0.2) and util - float(0.18) > float(self.call_model_lgb(bid)):
272 self.acceptance_condition = 5
273 return True
274 elif float(1.0) >= float(progress) > 0.97 and util - float(0.12) > float(self.call_model_lgb(bid)):
275 self.acceptance_condition = 6
276 return True
277 return False
278
279 def find_bid(self, progress_time):
280 progress_time = float(progress_time)
281 if float(self.my_offered_number_of_time_from_ai) < float(len(self.eva_util_val_acc_to_lgb_m_with_max_bids_for_agent)) * float(2) \
282 and ((0 < progress_time < 0.17) or (0.23 < progress_time < 0.37) or (0.45 < progress_time < 0.93) or (
283 0.97 < progress_time <= 0.985)) and self.lgb_model is not None \
284 and len(self.eva_util_val_acc_to_lgb_m_with_max_bids_for_agent) >= 1:
285 index = random.randint(0,
286 len(self.eva_util_val_acc_to_lgb_m_with_max_bids_for_agent) - 1)
287 if float(self.reservationBid_utility) < float(self.profile.getUtility(self.eva_util_val_acc_to_lgb_m_with_max_bids_for_agent[index])):
288 self.my_offered_number_of_time_from_ai = self.my_offered_number_of_time_from_ai + 1
289 return self.eva_util_val_acc_to_lgb_m_with_max_bids_for_agent[index]
290 elif ((0.25 < progress_time < 0.30) or (0.58 < progress_time < 0.64) or (0.82 < progress_time < 0.86) or (
291 0.965 < progress_time <= 0.995)) and self.lgb_model is not None and len(
292 self.eva_util_val_acc_to_lgb_m_with_max_bids_for_agent) >= 1:
293 index = random.randint(0, len(self.eva_util_val_acc_to_lgb_m_with_max_bids_for_agent) - 1)
294 if float(self.reservationBid_utility) < float(
295 self.profile.getUtility(self.eva_util_val_acc_to_lgb_m_with_max_bids_for_agent[index])):
296 return self.eva_util_val_acc_to_lgb_m_with_max_bids_for_agent[index]
297 elif progress_time < 0.4:
298 if self.number_of_bid_greater_than95 >= 8:
299 index = random.randint(self.number_of_bid_greater_than95 - 4, self.number_of_bid_greater_than95)
300 if float(self.reservationBid_utility) < float(self.profile.getUtility(self.sorted_bids_agent[index])):
301 return self.sorted_bids_agent[index]
302
303 elif self.number_of_bid_greater_than95 >= 4:
304 index = random.randint(3, self.number_of_bid_greater_than95)
305 if float(self.reservationBid_utility) < float(self.profile.getUtility(self.sorted_bids_agent[index])):
306 return self.sorted_bids_agent[index]
307
308 elif self.number_of_bid_greater_than95 >= 1:
309 index = random.randint(1, self.number_of_bid_greater_than95)
310 if float(self.reservationBid_utility) < float(self.profile.getUtility(self.sorted_bids_agent[index])):
311 return self.sorted_bids_agent[index]
312
313 elif self.number_of_bid_greater_than85 >= 1:
314 index = random.randint(1, self.number_of_bid_greater_than85)
315 if float(self.reservationBid_utility) < float(self.profile.getUtility(self.sorted_bids_agent[index])):
316 return self.sorted_bids_agent[index]
317
318 elif progress_time < 0.85:
319 if self.number_of_bid_greater_than95 > 1 and self.number_of_bid_greater_than85 > 2:
320 index = random.randint(self.number_of_bid_greater_than95, self.number_of_bid_greater_than85)
321 if float(self.reservationBid_utility) < float(self.profile.getUtility(self.sorted_bids_agent[index])):
322 return self.sorted_bids_agent[index]
323
324 elif self.number_of_bid_greater_than85 >= 1:
325 index = random.randint(1, self.number_of_bid_greater_than85)
326 if float(self.reservationBid_utility) < float(self.profile.getUtility(self.sorted_bids_agent[index])):
327 return self.sorted_bids_agent[index]
328
329 elif progress_time <= 0.975:
330 if self.number_of_goal_of_utility > self.number_of_bid_greater_than85:
331 index = random.randint(self.number_of_bid_greater_than85, self.number_of_goal_of_utility)
332 if float(self.reservationBid_utility) < float(self.profile.getUtility(self.sorted_bids_agent[index])):
333 return self.sorted_bids_agent[index]
334 elif self.number_of_goal_of_utility > self.number_of_bid_greater_than95:
335 index = random.randint(self.number_of_bid_greater_than95, self.number_of_goal_of_utility)
336 if float(self.reservationBid_utility) < float(self.profile.getUtility(self.sorted_bids_agent[index])):
337 return self.sorted_bids_agent[index]
338 elif self.number_of_goal_of_utility > 1:
339 index = random.randint(1, self.number_of_goal_of_utility)
340 if float(self.reservationBid_utility) < float(self.profile.getUtility(self.sorted_bids_agent[index])):
341 return self.sorted_bids_agent[index]
342 elif 0.91 <= progress_time <= 0.995:
343 if self.offers_unique_sorted is not None and not len(self.offers_unique_sorted) == 0:
344 bid = self.offers_unique_sorted[0]
345 util_of_bid = float(self.profile.getUtility(bid))
346 if float(self.reservationBid_utility) < float(util_of_bid) and float(util_of_bid) >= float(self.goal_of_utility) - float(0.03) and float(
347 self.call_model_lgb(bid)) < util_of_bid:
348 return bid
349 elif float(self.reservationBid_utility) < float(self.profile.getUtility(self.sorted_bids_agent[3])):
350 return self.sorted_bids_agent[3]
351 return self.sorted_bids_agent[0]
Note: See TracBrowser for help on using the repository browser.