def __init__(self):
self.moveFirst = False
self.firstOffer = False
self.currIter = 0
self.otherNegoWants = {}
self.visited = []
self.threshold = 0
BaseNegotiator.__init__(self)
def initialize(self, preferences, iter_limit):
BaseNegotiator.initialize(self, preferences, iter_limit)
self.counter = 0
self.offer = []
self.our_offers = []
self.opponent_offers = []
self.opponent_utilities = []
self.penalty = -1 * len(preferences)
self.histogram = [ [0 for i in range(0, len(preferences))] for i in range(0, len(preferences)) ]
self.opt_util = 0
def __init__(self):
BaseNegotiator.__init__(self)
self.round_count=0
self.first=False
self.their_offers=[]
self.their_utilities=[]
self.our_score=0
self.their_score=0
self.last_offer=None
self.encounter=0
self.agreed=False
def __init__(self):
BaseNegotiator.__init__(self)
self.given_results = []
self.going_first = False
self.aggressiveness = randint(40,60)
self.currentPts = 0
self.currentPtsOpponent = 0
self.is_opponent_jerk = False
self.stubborn_opponent = False
self.stubborn_count = 0
self.numRounds = 0
def initialize(self, preferences, iter_limit):
BaseNegotiator.initialize(self, preferences, iter_limit)
self.round_count = 0
self.first = False
self.their_offers = []
self.their_utilities = []
self.our_score = 0
self.their_score = 0
self.offer_space()
self.last_offer = None
self.encounter = 0
def initialize(self, preferences, iter_limit):
BaseNegotiator.initialize(self,preferences,iter_limit)
self.round_count=0
self.first=False
self.their_offers=[]
self.their_utilities=[]
self.our_score=0
self.their_score=0
self.offer_space()
self.last_offer=None
self.encounter=0
def __init__(self):
##set up window here
self.window = Tk()
self.window.geometry("500x500+300+100")
self.window.title("Human Negotiator")
self.buttonlist = []
self.madeoffer = False
BaseNegotiator.__init__(self)
self.checkstate = []
self.currUtility = StringVar()
self.lastOffer = StringVar()
self.theirUtility = "0"
def __init__(self):
##set up window here
self.window = Tk()
self.window.geometry("500x500+300+100")
self.window.title("Human Negotiator")
self.buttonlist = []
self.madeoffer = False
BaseNegotiator.__init__(self)
self.checkstate = []
self.currUtility = StringVar()
self.lastOffer = StringVar()
self.theirUtility = "0"
def make_offer(self, offer):
self.offer = offer
if random() < 0.125 and offer is not None:
self.offer = BaseNegotiator.set_diff(self)
return self.offer
else:
ordering = self.preferences
ourOffer = []
for item in ordering.keys():
if random() < 0.2:
ourOffer = ourOffer + [item]
self.offer = ourOffer
self.offer = BaseNegotiator.set_diff(self)
return self.offer
def __init__(self):
BaseNegotiator.__init__(self)
self.turn_counter = 0
self.their_last_offer_utility = 0
self.results = 0
self.is_first = False
# time at which we think we have a reasonable grasp on their offer
self.turn_model_becomes_accurate = self.iter_limit * .20
# container of probabilities
self.mastermind_probabilities = []
self.their_previous_offer_utility = 0
self.current_guess = []
self.optimal_solution_guess = []
self.last_guess = []
def initialize(self, preferences, iter_limit):
BaseNegotiator.initialize(self,preferences, iter_limit)
self.offer = self.preferences[:]
self.num_iters = iter_limit
temp_options = list(itertools.permutations(self.offer,len(self.offer)))
#print (temp_options)
for option in temp_options:
temp_util = int(round(self.evaluate(option),0))
if(temp_util not in self.options.keys()):
self.options[temp_util] = []
self.options[temp_util].append(option)
#print (self.options)
self.util_levels = sorted(self.options.keys(), reverse = True)
self.current_level = 0
self.stepsize = math.ceil( iter_limit / len(self.util_levels))
self.step = self.stepsize
def initialize(self, preferences, iter_limit):
##add all items to window
self.preferences = preferences
latestOffer = Label(self.window, textvariable = self.lastOffer).pack()
currentUtility = Label(self.window, textvariable=self.currUtility).pack()
self.currUtility.set("Your Share's Utility: 0")
self.lastOffer.set("None")
i = 0
for x in self.preferences:
y = self.preferences.get(x,0)
print str(y)
buttonvar = IntVar()
self.buttonlist.append(buttonvar)
newCheckbutton = Checkbutton(self.window, text = str(x) + " = " + str(y),variable = self.buttonlist.__getitem__(i), command = self.updateItem).pack()
i+=1
sendButton = Button(self.window, text = "Send Offer",command = self.sendoffer).pack()
BaseNegotiator.initialize(self, preferences, iter_limit)
def __init__(self):
BaseNegotiator.__init__(self)
self.results = {}
self.successful_results = []
self.best_threshold = 0.5
self.enemy_first_offer = []
self.enemy_avg_slope = 0
self.enemy_greed_slope = 0
self.last_enemy_util = 0
self.our_last_offer = []
self.first = False
self.enemy_util_slope = []
self.init_enemy_util = 0
self.enemy_util = []
self.last_util = 0
self.THRESHOLD = 0.9
self.max_utility = 0
self.threshold_increment = 0.1
self.offers_made = []
self.round = 1
def make_offer(self, offer):
self.offer = offer
self.currIter+=1
if self.currIter == self.iter_limit+1:
self.offer = BaseNegotiator.set_diff(self)
return self.offer
if random() < 0 and offer is not None:
# Very important - we save the offer we're going to return as self.offer
print "I agree that you can take " + str(self.offer)
self.offer = BaseNegotiator.set_diff(self)
print "I will take: " + str(self.offer)
return self.offer
else:
ordering = self.preferences
ourOffer = []
for item in ordering.keys():
if random() < .5:
ourOffer = ourOffer + [item]
self.offer = ourOffer
return self.offer
def __init__(self):
BaseNegotiator.__init__(self)
self.results = {}
self.successful_results = []
self.best_threshold = 0.5
self.enemy_first_offer = []
self.enemy_avg_slope = 0
self.enemy_greed_slope = 0
self.last_enemy_util = 0
self.our_last_offer = []
self.first = False
self.enemy_util_slope = []
self.init_enemy_util = 0
self.enemy_util = []
self.last_util = 0
self.THRESHOLD = 0.9
self.max_utility = 0
self.threshold_increment = 0.1
self.offers_made = []
self.round = 1
def initialize(self, preferences, iter_limit):
##add all items to window
self.preferences = preferences
latestOffer = Label(self.window, textvariable=self.lastOffer).pack()
currentUtility = Label(self.window,
textvariable=self.currUtility).pack()
self.currUtility.set("Your Share's Utility: 0")
self.lastOffer.set("None")
i = 0
for x in self.preferences:
y = self.preferences.get(x, 0)
print str(y)
buttonvar = IntVar()
self.buttonlist.append(buttonvar)
newCheckbutton = Checkbutton(
self.window,
text=str(x) + " = " + str(y),
variable=self.buttonlist.__getitem__(i),
command=self.updateItem).pack()
i += 1
sendButton = Button(self.window,
text="Send Offer",
command=self.sendoffer).pack()
BaseNegotiator.initialize(self, preferences, iter_limit)
def make_offer(self, offer):
self.offer = offer
if random() < 0.2 and offer is not None:
# Very important - we save the offer we're going to return as self.offer
print("I agree that you can take " + str(self.offer))
self.offer = BaseNegotiator.set_diff(self)
print("I will take: " + str(self.offer))
return self.offer
else:
ordering = self.preferences
ourOffer = []
for item in ordering.keys():
if random() < .5:
ourOffer = ourOffer + [item]
self.offer = ourOffer
return self.offer
def make_offer(self, offer):
self.offer = offer
if random() < 0.1 and offer is not None:
# Very important - we save the offer we're going to return as self.offer
print "[RN]Random Negotiator agree that you can take " + str(self.offer)
self.offer = BaseNegotiator.set_diff(self)
print "[RN]Random Negotiator will take: " + str(self.offer)
return self.offer
else:
ordering = self.preferences
ourOffer = []
for item in ordering.keys():
if random() < 0.5:
ourOffer = ourOffer + [item]
print "[RN]Random Negotiator made an offer" + str(ourOffer)
self.offer = ourOffer
return self.offer
def __init__(self):
BaseNegotiator.__init__(self)
self.going_first = False
def utility(self):
x = BaseNegotiator.utility(self)
return x
def receive_results(self, results):
BaseNegotiator.receive_results(self, results)
def __init__(self):
self.moveFirst = False
self.currIter = 0
BaseNegotiator.__init__(self)
def receive_results(self, results):
BaseNegotiator.receive_results(self, results)
def make_offer(self, offer):
modifiedOffers = []
if self.threshold == 0:
# will generate threshold from .4 - .5 based on num of items
self.threshold = .5 - (len(self.preferences)/10000.0)
# init dictionary
if len(self.otherNegoWants) == 0:
for item in self.preferences:
self.otherNegoWants[item] = 0
# init total util
if "total_util" not in locals():
self.get_total_util()
# init moveFirst
if offer is None:
self.moveFirst = True
# update dictionary
else:
for item in offer:
self.otherNegoWants[item] = self.otherNegoWants[item] + 1
self.currIter+=1
self.offer = offer
#print "Current Iter: " + str(self.currIter)
#print "Offers: " + str(offers)
#print "Modified Offer: " + str(modifiedOffers)
#print "offer given:" + str(offer)
# almost all or nothing - final offer
if self.moveFirst and self.currIter == self.iter_limit:
ignore_item = self.get_lowest_item(None)
final_offer = []
items = self.preferences
for item in items:
if item != ignore_item:
final_offer = final_offer + [item]
print "Making last offer: " + str(final_offer)
self.offer = final_offer
return self.offer
if self.currIter == self.iter_limit:
print "Last Accept Offer: " + str(BaseNegotiator.set_diff(self)) + str(self.offer)
# TODO
self.offer = BaseNegotiator.set_diff(self)
return self.offer
# evaluate offer
print "Expected val: " + str(.5 * self.total_util)
if self.offer is not None:
print "Offered val: " + str(self.get_offer_util(BaseNegotiator.set_diff(self)))
if self.moveFirst and self.offer is not None and self.get_offer_util(BaseNegotiator.set_diff(self)) > (.5 * self.total_util):
self.offer = BaseNegotiator.set_diff(self)
return self.offer
elif self.offer is not None and self.get_offer_util(BaseNegotiator.set_diff(self)) >= (self.threshold*self.total_util):
self.offer = BaseNegotiator.set_diff(self)
return self.offer
# make offer
offers = self.generate_offers()
print "All offers: " + str(offers)
# will try best offer first, rest will be random
choice = 0
while choice in self.visited:
choice = randint(0, len(offers)-1)
self.visited += [choice]
# if we've visited all, empty
if len(self.visited) == len(offers):
self.visited = []
self.offer = offers[choice]
print "Current Iter: " + str(self.currIter)
print "Current Offer: " + str(self.offer)
return self.offer
def initialize(self, preferences, iter_limit):
BaseNegotiator.initialize(self,preferences,iter_limit)
self.offer_space()
def initialize(self, preferences, iter_limit):
BaseNegotiator.initialize(self, preferences, iter_limit)
self.counter = 0
self.penalty = -1 * len(preferences)
self.offer = []
def initialize(self, preferences, iter_limit):
BaseNegotiator.initialize(self,preferences, iter_limit)
self.offer = self.preferences[:]
self.max_util = round(self.utility(), 5)
self.calculate_combos(self.preferences)
self.set_up_weighted_avg()
def make_offer(self, offer):
self.offer = offer
global maxTurns
global oppo_dict
# print the number of current turn
# print self.make_offer.count
# get the current turn
currentTurn = self.make_offer.count
# update opponent's offer in our tracker
oppo_dict = self.oppoEstimation(offer)
# print "oppo_dict: " + str(oppo_dict)
if currentTurn is 1:
if offer is None:
# If going first, first turn decision = offer all positive util items
maxTurns = ky2cg.getTurns(self) + 1
# print "[SS}ss2cp starts first, incrementing the max turn by 1, max turns is " + str(maxTurns)
# then there will be an extra chance to accept an offer in the end
self.offer = self.positiveItems()
# print "[SS]ss2cp will take: " + str(self.offer) + ". My utility will be " + str(self.utility())
return self.offer
if offer is not None:
maxTurns = ky2cg.getTurns(self)
# print "[SS}ss2cp starts second, max turns remains " + str(maxTurns)
# then there will be no extra chance to accept an offer in the end
# to see if it is the last turn, and accept what ever offer
if currentTurn is maxTurns:
if currentTurn > ky2cg.getTurns(self):
# then you are to accept the final offer
self.offer = offer
self.offer = BaseNegotiator.set_diff(self)
if (self.utility() >= (self.totalUtility() / 3)):
# print "[SS]Last chance to accept offer, will accept any offer more than 1/3 of my total utility: " + str(
# self.offer) + " vs " + str(
# offer) + ". My utility will be " + str(self.utility()) + ". total/3 is " + str(
# self.totalUtility() / 3)
return self.offer
else:
self.offer = BaseNegotiator.set_diff(self)
# print "You bad!!! I'd rather get negative leward!!!!"
return self.offer
else:
# then you are to give the final offer
# print "[SS]Last chance to give offer, will take more than 2/3 of my total utility"
# print "oppo_dict: " + str(oppo_dict)
total = 0
ourOffer = []
# look at the nonoffered items first
ordering = self.preferences
for item in ordering.keys():
if not oppo_dict:
break
if (item not in oppo_dict and ordering.get(item) >= 0):
ourOffer = ourOffer + [item]
total += ordering.get(item)
# print "Found an item that opponent never wanted, " + str(
# item) + ". It's value is positive, taking it. That give me total of " + str(total)
if (total >= (2 / 3 * self.totalUtility())):
self.offer = ourOffer
# print "[SS]ss2cp will take: " + str(ourOffer) + ". My utility will be " + str(
# self.utility())
return self.offer
while total < (2 / 3 * self.totalUtility()):
min = min(oppo_dict, key=oppo_dict.get)
ourOffer = ourOffer + min
total += oppo_dict.get(min)
del oppo_dict[min]
self.offer = ourOffer
# print "[SS]ss2cp will take: " + str(ourOffer) + ". My utility will be " + str(
# self.utility())
return self.offer
if offer is not None:
# Very important - we save the offer we're going to return as self.offer
self.offer = offer
# If so, accept, negotiation is completed!
if self.acceptableOffer() is True:
# print("OFFER ACCEPTABLE!!! TAKING IT!!!!")
# self.offer = BaseNegotiator.set_diff(self)
# self.offer = self.positiveRemainingItems()
return self.offer
# Else, return more favorable offer to opponent
else: # Opponent offer currently takes more than half of total utilities
# print("ARRANGING COUNTER OFFER!!!!!!!!!!")
currOffer = offer # Save opponent offer to modify
self.offer = BaseNegotiator.set_diff(self)
ourOffer = self.positiveRemainingItems(
) # Instantiate our offer, currently < 1/2 * total utilities
ourOfferUtil = 0 # Track our offer's utility
for s in ourOffer:
ourOfferUtil += self.preferences.get(s, 0)
# Loop: while our offer is still < 2/3 of total utility
while ourOfferUtil < (2 * self.totalUtility() / 3):
if len(currOffer) > 0:
maxItem = self.maxItem(currOffer) # Find min item in opponent's offer
ourOffer = ourOffer + [maxItem]
ourOfferUtil += self.preferences.get(maxItem, 0)
currOffer.remove(maxItem)
else:
break
# print("COUNTER OFFER: ")
# for s in ourOffer:
# print(s)
self.offer = ourOffer
# print "[SS]ss2cp will take: " + str(self.offer) + ". My utility will be " + str(self.utility())
return self.offer
def utility(self):
x = BaseNegotiator.utility(self)
return x
