def main_exp3(bidder, curr_rep, T, num_bidders, num_slots, outcome_space,
rank_scores, ctr, reserve, values, bids, threshold, noise):
algo_util = []
temp_regr = []
clean_alloc = [[] for _ in range(0, T)]
for t in range(0, T):
bid_chosen = bidder.bidding()
bids[t][0] = bid_chosen
bid_vec = deepcopy(bids[t])
gsp_instance = GSP(ctr[t], reserve[t], bid_vec, rank_scores[t],
num_slots, num_bidders)
allocated = gsp_instance.alloc_func(bidder.id, bids[t][bidder.id])
clean_alloc[t] = [
gsp_instance.alloc_func(bidder.id, bid * bidder.eps)
for bid in range(0, bidder.bid_space)
]
temp_alloc = deepcopy(clean_alloc[t])
noise_cp = deepcopy(noise)
bidder.alloc_func[t] = noise_mask(temp_alloc, noise_cp[t], ctr[t],
num_slots)
#reward function: value - payment(coming from GSP module)
bidder.pay_func[t] = [
gsp_instance.pay_func(bidder.id, bid * bidder.eps)
for bid in range(0, bidder.bid_space)
]
if allocated > threshold[t]:
bidder.reward_func[t] = [(values[t][0] - bidder.pay_func[t][b])
for b in range(0, bidder.bid_space)]
else:
bidder.reward_func[t] = [0 for _ in range(0, bidder.bid_space)]
bidder.utility[t] = normalize(bidder.reward_func[t], bidder.bid_space,
0, 1)
#weights update
arm_chosen = int(math.ceil(bids[t][0] / bidder.eps))
if bidder.pi[arm_chosen] < 0.0000000001:
bidder.pi[arm_chosen] = 0.0000000001
estimated_loss = bidder.utility[t][arm_chosen] / bidder.pi[arm_chosen]
bidder.loss[arm_chosen] += estimated_loss
arr = np.array([(-bidder.eta_exp3) * bidder.loss[b]
for b in range(0, bidder.bid_space)],
dtype=np.float128)
bidder.weights = np.exp(arr)
bidder.pi = [
bidder.weights[b] / sum(bidder.weights)
for b in range(0, bidder.bid_space)
]
#algo_util.append((bidder.reward_func[t][arm_chosen]*bidder.alloc_func[t][arm_chosen]))
algo_util.append(
(bidder.reward_func[t][arm_chosen] * clean_alloc[t][arm_chosen]))
temp_regr.append(
regret(bidder.reward_func, clean_alloc, bidder.bid_space,
algo_util, t))
return temp_regr
def main_winexp(bidder, curr_rep, T, num_bidders, num_slots, outcome_space,
rank_scores, ctr, reserve, values, bids, threshold, noise):
algo_util = []
temp_regr = []
clean_alloc = [[] for _ in range(0, T)]
for t in range(0, T):
bid_chosen = bidder.bidding()
bids[t][0] = bid_chosen
bid_vec = deepcopy(bids[t])
gsp_instance = GSP(ctr[t], reserve[t], bid_vec, rank_scores[t],
num_slots, num_bidders)
# this is not reported to the bidder, and thus is cleaned of noise
allocated = gsp_instance.alloc_func(bidder.id, bids[t][bidder.id])
clean_alloc[t] = [
gsp_instance.alloc_func(bidder.id, bid * bidder.eps)
for bid in range(0, bidder.bid_space)
]
temp = deepcopy(clean_alloc[t])
# bidder sees noisy data as his allocation
noise_cp = deepcopy(noise)
bidder.alloc_func[t] = noise_mask(temp, noise_cp[t], ctr[t], num_slots)
#reward function: value - payment(coming from GSP module)
bidder.pay_func[t] = [
gsp_instance.pay_func(bidder.id, bid * bidder.eps)
for bid in range(0, bidder.bid_space)
]
#### WIN-EXP computations ####
# computation of reward will only be used for the regret
if allocated > threshold[t]:
bidder.reward_func[t] = [(values[t][0] - bidder.pay_func[t][b])
for b in range(0, bidder.bid_space)]
bidder.utility[t] = bidder.compute_utility(1,
bidder.reward_func[t],
bidder.alloc_func[t])
else:
bidder.reward_func[t] = [0 for _ in range(0, bidder.bid_space)]
bidder.utility[t] = (bidder.compute_utility(
0, bidder.reward_func[t], bidder.alloc_func[t]))
(bidder.weights,
bidder.pi) = bidder.weights_update_winexp(bidder.eta_winexp,
bidder.utility[t])
# for each auction (at the same t) you choose the same arm
arm_chosen = int(math.ceil(bids[t][bidder.id] / bidder.eps))
algo_util.append(
(bidder.reward_func[t][arm_chosen] * clean_alloc[t][arm_chosen]))
temp_regr.append(
regret(bidder.reward_func, clean_alloc, bidder.bid_space,
algo_util, t))
return temp_regr
def main_exp3(bidder,curr_rep, T,num_bidders, num_slots, outcome_space, rank_scores, ctr, reserve, values,bids,threshold,noise,num_adaptive):
algo_util = []
temp_regr = []
clean_alloc = [[] for _ in range(0,T)]
for t in range(0,T):
bid_chosen = [bidder[i].bidding() for i in range(0,num_adaptive)]
for i in range(0,num_adaptive):
bids[t][i] = bid_chosen[i]
bid_vec = deepcopy(bids[t])
gsp_instance =GSP(ctr[t], reserve[t], bid_vec, rank_scores[t], num_slots, num_bidders)
arm_chosen =[0]*num_adaptive
for i in range(0,num_adaptive):
allocated = gsp_instance.alloc_func(bidder[i].id, bids[t][bidder[i].id])
temp = [gsp_instance.alloc_func(bidder[i].id, bid*bidder[i].eps) for bid in range(0, bidder[i].bid_space)]
if (i == 0):
clean_alloc[t] = deepcopy(temp)
noise_cp = deepcopy(noise)
bidder[i].alloc_func[t] = noise_mask(temp,noise_cp[t],ctr[t], num_slots)
#reward function: value - payment(coming from GSP module)
bidder[i].pay_func[t] = [gsp_instance.pay_func(bidder[i].id, bid*bidder[i].eps) for bid in range(0, bidder[i].bid_space)]
if (i == 0):
if allocated > threshold[t]:
bidder[i].reward_func[t] = [(values[t][i] - bidder[i].pay_func[t][b]) for b in range(0,bidder[i].bid_space)]
else:
bidder[i].reward_func[t] = [0 for _ in range(0,bidder[i].bid_space)]
bidder[i].utility[t] = bidder[i].reward_func[t]
#weights update
arm_chosen[i] = int(math.ceil(bids[t][i]/bidder[i].eps))
if bidder[i].pi[arm_chosen[i]] < 0.0000000001:
bidder[i].pi[arm_chosen[i]] = 0.0000000001
estimated_loss = -bidder[i].utility[t][arm_chosen[i]]/bidder[i].pi[arm_chosen[i]]
bidder[i].loss[arm_chosen[i]] += estimated_loss
arr = np.array([(-bidder[i].eta_exp3)*bidder[i].loss[b] for b in range(0,bidder[i].bid_space)], dtype=np.float128)
bidder[i].weights = np.exp(arr)
bidder[i].pi = [bidder[i].weights[b]/sum(bidder[i].weights) for b in range(0,bidder[i].bid_space)]
else:
if allocated > threshold[t]:
bidder[i].reward_func[t] = [(values[t][0] - bidder[i].pay_func[t][b]) for b in range(0,bidder[i].bid_space)]
bidder[i].utility[t] = bidder[i].compute_utility(1, bidder[i].reward_func[t], bidder[i].alloc_func[t])
else:
bidder[i].reward_func[t] = [0 for _ in range(0,bidder[i].bid_space)]
bidder[i].utility[t] = (bidder[i].compute_utility(0, bidder[i].reward_func[t], bidder[i].alloc_func[t]))
(bidder[i].weights, bidder[i].pi) = bidder[i].weights_update_winexp(bidder[i].eta_winexp, bidder[i].utility[t])
algo_util.append((bidder[0].reward_func[t][arm_chosen[0]]*clean_alloc[t][arm_chosen[0]]))
temp_regr.append(regret(bidder[0].reward_func,clean_alloc,bidder[0].bid_space, algo_util,t))
return temp_regr
def expected_utils(self, t, history, reserve):
"""
Figure out the expected utility of bidding such that we win each
slot, assuming that everyone else keeps their bids constant from
the previous round.
returns a list of utilities per slot.
"""
# TODO: Fill this in
last_round = history.round(t-1)
last_round_bids = filter(lambda (ID, bid):ID != self.id, last_round.bids)
last_round_clicks = last_round.clicks
allocation, _ = GSP.compute(last_round_clicks, reserve, last_round_bids)
num_slots = len(allocation)
utilities = []
for slot in range(num_slots):
last_round_k = allocation[slot] #take the person from last round in slot k
bid_i = reserve # default bid to reserve price
for ID, bid in last_round_bids: # go through each of last rounds' bids, and set that slot's bid
if last_round_k == ID:
bid_i = bid
utilities += [(self.value - bid_i) * last_round_clicks[slot]]
if utilities == []:
return [0]
return utilities
def runSecondPriceAuction(self, reqList, seller):
'''
Function to call GSP mechanism
'''
sellerGraph = seller.getSellerGraph()
allocation = []
self.__logger.debug("[AdExchange][runSecondPriceAuction]")
self.__logger.debug("Fiber allocation decisions.")
allocationDict = {}
ip_port_pairs = []
for key, v in reqList.items():
k1, k2 = key.split("#")
# n denotes the number of customers bidding for that conduit
n = len(v)
slot_click = [1] * n
try:
shortestPath = nx.shortest_path(sellerGraph,
source=k1,
target=k2)
gCoP = self.getCostOfPath(shortestPath, sellerGraph)
lIP = self.linksInPath(shortestPath)
k = len(lIP)
reserve = max(self.__reserve, gCoP / k)
bids = []
for item in v:
bids.append((item.clientName, item.bidPerStrand))
if nx.has_path(sellerGraph, k1, k2) and self.resourceAvailable(
sellerGraph, shortestPath, v):
(alloc, payments) = GSP.compute(slot_click, reserve, bids)
allocation.extend(zip(alloc, [i * k for i in payments]))
for (kTest, vTest) in allocation:
allocationDict[kTest] = vTest
# Updates sellerGraph with the allocation
self.__logger.debug("Before > {}".format(
self.availableAttributes(shortestPath, sellerGraph)))
ip_port_pairs = self.updateSellerGraph_and_getResources(
seller, shortestPath, v)
self.__logger.debug("After > {}".format(
self.availableAttributes(shortestPath, sellerGraph)))
else:
self.__logger.info(
"Link does not exists between {} and {}. No resource available for request"
.format(k1, k2))
except nx.NodeNotFound:
self.__logger.info(
"Path does not exists between {} and {}. No resource available for request"
.format(k1, k2))
allocationDict = {}
break
return (self.updateRequestList(reqList, allocationDict), ip_port_pairs)
def bid_range_for_slot(slot, slot_clicks, reserve, bids):
"""
Compute the range of bids that would result in the bidder ending up
in slot, given that the other bidders submit bidders.
Returns a tuple (min_bid, max_bid).
If slot == 0, returns None for max_bid, since it's not well defined.
"""
# Conveniently enough, bid ranges are the same for GSP and VCG:
return GSP.bid_range_for_slot(slot, slot_clicks, reserve, bids)
def bid_range_for_slot(slot, slot_clicks, reserve, bids):
"""
Compute the range of bids that would result in the bidder ending up
in slot, given that the other bidders submit bidders.
Returns a tuple (min_bid, max_bid).
If slot == 0, returns None for max_bid, since it's not well defined.
"""
# Conveniently enough, bid ranges are the same for GSP and VCG:
return GSP.bid_range_for_slot(slot, slot_clicks, reserve, bids)
def test_mechanism():
num_slots = 4
slot_clicks = [1] * 4 # don't actually matter for gsp
bids = zip(range(1, 6), [10, 12, 18, 14, 20])
reserve = 0
(alloc, payments) = GSP.compute(slot_clicks, reserve, bids)
assert alloc == [5, 3, 4, 2]
assert payments == [18, 14, 12, 10]
reserve = 11
(alloc, payments) = GSP.compute(slot_clicks, reserve, bids)
assert alloc == [5, 3, 4, 2]
assert payments == [18, 14, 12, 11]
reserve = 14
(alloc, payments) = GSP.compute(slot_clicks, reserve, bids)
assert alloc == [5, 3, 4]
assert payments == [18, 14, 14]
reserve = 15
(alloc, payments) = GSP.compute(slot_clicks, reserve, bids)
assert alloc == [5, 3]
assert payments == [18, 15]
reserve = 19
(alloc, payments) = GSP.compute(slot_clicks, reserve, bids)
assert alloc == [5]
assert payments == [19]
reserve = 22
(alloc, payments) = GSP.compute(slot_clicks, reserve, bids)
assert alloc == []
assert payments == []
def main_winexp(bidder,curr_rep, T,num_bidders, num_slots, outcome_space, rank_scores, ctr, reserve, values,bids,threshold, noise,num_adaptive):
algo_util = []
temp_regr = []
clean_alloc = [[] for _ in range(0,T)]
clean_pay = [[] for _ in range(0,T)]
clean_reward = [[] for _ in range(0,T)]
for t in range(0,T):
bid_chosen = [bidder[i].bidding() for i in range(0,num_adaptive)]
for i in range(0,num_adaptive):
bids[t][i] = bid_chosen[i]
bid_vec = deepcopy(bids[t])
gsp_instance =GSP(ctr[t], reserve[t], bid_vec, rank_scores[t], num_slots, num_bidders)
arm_chosen = [int(math.ceil(bids[t][i]/bidder[i].eps)) for i in range(0,num_adaptive)]
for i in range(0,num_adaptive):
allocated = gsp_instance.alloc_func(bidder[i].id, bids[t][bidder[i].id])
temp = [gsp_instance.alloc_func(bidder[i].id, bid*bidder[i].eps) for bid in range(0, bidder[i].bid_space)]
if (i == 0):
clean_alloc[t] = deepcopy(temp)
clean_pay[t] = [gsp_instance.pay_func(bidder[i].id, bid*bidder[i].eps) for bid in range(0,bidder[i].bid_space)]
temp_pay = gsp_instance.pay_func(bidder[i].id, bid_vec[i])
bidder[i].payment[t] = temp_pay
# bidder sees noisy data as his allocation
noise_cp = deepcopy(noise)
bidder[i].currbid[t] = arm_chosen[i]*bidder[i].eps
if allocated > threshold[t]:
bidder[i].allocated[t] = 1
bidder[i].alloc_func[t] = compute_allocation_function(bidder[i].currbid[:t+1], bidder[i].allocated[:t+1], bidder[i].bid_space, bidder[i].eps)
bidder[i].alloc_func[t][arm_chosen[i]] = allocated
bidder[i].pay_func[t] = compute_payment_function(bidder[i].currbid[:t+1], bidder[i].payment[:t+1], bidder[i].bid_space, bidder[i].eps)
bidder[i].pay_func[t][arm_chosen[i]] = bidder[i].payment[t]
temp_reward = [(values[t][0] - bidder[i].pay_func[t][b]) for b in range(0,bidder[i].bid_space)]
if (i == 0):
clean_reward[t] = [(values[t][0] - clean_pay[t][b]) for b in range(0,bidder[i].bid_space)]
bidder[i].reward_func[t] = normalize(temp_reward,bidder[i].bid_space,-1,1)
bidder[i].utility[t] = (bidder[i].compute_utility(1, bidder[i].reward_func[t], bidder[i].alloc_func[t]))
else:
bidder[i].allocated[t] =0
bidder[i].alloc_func[t] = compute_allocation_function(bidder[i].currbid[:t+1], bidder[i].allocated[:t+1], bidder[i].bid_space, bidder[i].eps)
bidder[i].alloc_func[t][arm_chosen[i]] = allocated
bidder[i].payment[t] = 0
bidder[i].pay_func[t] = [0]*bidder[i].bid_space
temp_reward = [0 for _ in range(0,bidder[i].bid_space)]
bidder[i].reward_func[t] = normalize(temp_reward,bidder[i].bid_space,-1,1)
if (i == 0):
clean_reward[t] = [0 for _ in range(0,bidder[i].bid_space)]
bidder[i].utility[t] = (bidder[i].compute_utility(0, bidder[i].reward_func[t], bidder[i].alloc_func[t]))
(bidder[i].weights, bidder[i].pi) = bidder[i].weights_update_winexp(bidder[i].eta_winexp, bidder[i].utility[t])
algo_util.append((clean_reward[t][arm_chosen[0]]*clean_alloc[t][arm_chosen[0]]))
temp_regr.append(regret(clean_reward,clean_alloc,bidder[0].bid_space, algo_util,t))
return temp_regr
def extract_patterns(transactions, min_support_threshold):
user_gsp_patterns = {}
for uid, transList in transactions.items():
gsp_patterns = GSP(transList).search(min_support_threshold)
print("========= Status =========", uid)
# print("Transactions: {}".format(transactions))
print("GSP: {}".format(gsp_patterns))
if len(gsp_patterns) > 1:
len_wise_patterns = list(
map(lambda d: list(d.keys()), gsp_patterns[1:]))
all_len_patterns = [
patt for len_patts in len_wise_patterns for patt in len_patts
]
print("Found patterns of length >=2 for user {} and patts: {}".
format(uid, all_len_patterns))
user_gsp_patterns[uid] = all_len_patterns
print("Filtered GSP patterns:\n", user_gsp_patterns)
return user_gsp_patterns
def runSecondPriceAuction(self, reqList, sellerGraph):
'''
Function to call GSP mechanism
'''
allocation = []
self.__logger.debug("[AdExchange][runSecondPriceAuction]")
self.__logger.debug("Fiber allocation decisions.")
allocationDict = {}
for key, v in reqList.items():
k1,k2=key.split("#")
# n denotes the number of customers bidding for that conduit
n = len(v)
slot_click = [1] * n
shortestPath = nx.shortest_path(sellerGraph, source=k1, target=k2)
gCoP = self.getCostOfPath(shortestPath, sellerGraph)
lIP = self.linksInPath(shortestPath)
k = len(lIP)
reserve = max(self.__reserve, gCoP/k)
bids = []
for item in v:
bids.append((item.clientName, item.bidPerStrand))
if nx.has_path(sellerGraph, k1, k2) and self.resourceAvailable(sellerGraph, shortestPath, v):
(alloc, payments) = GSP.compute(slot_click, reserve, bids)
allocation.extend(zip(alloc, [i * k for i in payments]))
for (kTest, vTest) in allocation:
allocationDict[kTest] = vTest
# Updates sellerGraph with the allocation
self.__logger.debug("Before > {}".format(self.availableAttributes(shortestPath, sellerGraph)))
self.updateSellerGraph(sellerGraph, shortestPath, v)
self.__logger.debug("After > {}".format(self.availableAttributes(shortestPath, sellerGraph)))
else:
self.__logger.info("Link does not exists or No resources available for the request")
return self.updateRequestList(reqList, allocationDict)
def test_mechanism():
num_slots = 4
slot_clicks = [1] * 4 # don't actually matter for gsp
bids = zip(range(1,6), [10, 12, 18, 14, 20])
reserve = 0
(alloc, payments) = GSP.compute(slot_clicks, reserve, bids)
assert alloc == [5,3,4,2]
assert payments == [18, 14, 12, 10]
reserve = 11
(alloc, payments) = GSP.compute(slot_clicks, reserve, bids)
assert alloc == [5,3,4,2]
assert payments == [18, 14, 12, 11]
reserve = 14
(alloc, payments) = GSP.compute(slot_clicks, reserve, bids)
assert alloc == [5,3,4]
assert payments == [18, 14, 14]
reserve = 15
(alloc, payments) = GSP.compute(slot_clicks, reserve, bids)
assert alloc == [5,3]
assert payments == [18, 15]
reserve = 19
(alloc, payments) = GSP.compute(slot_clicks, reserve, bids)
assert alloc == [5]
assert payments == [19]
reserve = 22
(alloc, payments) = GSP.compute(slot_clicks, reserve, bids)
assert alloc == []
assert payments == []
def compute(s):
(min, max) = GSP.bid_range_for_slot(s, clicks, reserve, other_bids)
if max == None:
max = 2 * min
return (s, min, max)
import argparse
import logging
import random
import re
from gsp import GSP
logging.basicConfig(level=logging.DEBUG)
def read_file(filepath) -> [str]:
rows = []
with open(filepath) as fp:
for cnt, line in enumerate(fp):
rows.append(line.replace("\r", "").replace("\n", "").split())
return rows
transactions = read_file('test.txt')
result = GSP(transactions).search(0.1)
print("========= Status =========")
print("Transactions: {}".format(transactions))
print("GSP: {}".format(result))
def compute(s):
(min, max) = GSP.bid_range_for_slot(s, clicks, reserve, other_bids)
if max == None:
max = 2 * min
return (s, min, max)
def main_gexp3(bidder, curr_rep, T, num_bidders, num_slots, outcome_space,
rank_scores, ctr, reserve, values, bids, num_auctions):
algo_util = []
temp_regr = []
gamma = 1.05 * math.sqrt(
bidder.bid_space * math.log(bidder.bid_space, 2) / T)
for t in range(0, T):
#bid_chosen = round(bidder.gbidding(bidder.weights,gamma),2)
bid_chosen = round(bidder.bidding(), 2)
# the bid chosen by the learner is the same for all auctions in the batch
for auction in range(0, num_auctions):
#bid_chosen = round(np.random.uniform(0,1),1)
#bid_chosen = round(np.random.uniform(0,1),2)
#print ("Bid chosen for timestep t=%d is:%f"%(t,bid_chosen))
#bid_chosen = round(np.random.uniform(0,1),2)
bids[auction][t][0] = bid_chosen
#print ("Repetition=%d, timestep t=%d, auction=%d"%(curr_rep, t, auction))
#print ("Rank scores")
#print rank_scores[auction][t]
#print ("CTR")
#print ctr[auction][t]
#print ("reserve")
#print reserve[auction][t]
#print ("bids")
#print bids[auction][t]
allocated = GSP(ctr[auction][t], reserve[auction][t],
bids[auction][t], rank_scores[auction][t],
num_slots, num_bidders).alloc_func(
bidder.id, bids[auction][t][bidder.id])
bidder.alloc_func[auction][t] = [
GSP(ctr[auction][t], reserve[auction][t], bids[auction][t],
rank_scores[auction][t], num_slots,
num_bidders).alloc_func(bidder.id, bid * bidder.eps)
for bid in range(0, bidder.bid_space)
]
#print ("alloc func")
#print bidder.alloc_func
#reward function: value - payment(coming from GSP module)
bid_vec = deepcopy(bids[auction][t])
bidder.pay_func[t] = [
GSP(ctr[auction][t], reserve[auction][t], bid_vec,
rank_scores[auction][t], num_slots,
num_bidders).pay_func(bidder.id, bid * bidder.eps)
for bid in range(0, bidder.bid_space)
]
#print ("pay func")
#print bidder.pay_func
bidder.reward_func[auction][t] = compute_reward(
bidder.alloc_func[auction][t], bidder.pay_func[t],
ctr[auction][t], values[auction][t])
#print ("Bidder's Reward function")
#print bidder.reward_func
#### EXP3 computations ####
#bidder.utility[auction][t] = [bidder.reward_func[auction][t][b]*bidder.alloc_func[auction][t][b] - 1 for b in range(0, bidder.bid_space)]
#bidder.utility[t] = [bidder.reward_func[t][b]*bidder.alloc_func[t][b] - 1 for b in range(0, bidder.bid_space)]
#print ("Bidder %d utility"%bidder.id)
#print bidder.utility
u_s = [0 for _ in range(0, bidder.bid_space)]
for b in range(0, bidder.bid_space):
for auction in range(0, num_auctions):
u_s[b] += bidder.reward_func[auction][t][
b] * bidder.alloc_func[auction][t][b]
bidder.avg_utility[t].append(u_s[b] / num_auctions - 1)
#weights update
arm_chosen = int(math.ceil(bids[0][t][0] / bidder.eps))
#print ("Arm Chosen")
#print arm_chosen
#print ("Average reward at timestep t=%d is:"%t)
#print (bidder.avg_reward[t])
#print ("Average utility at timestep t=%d is:"%t)
#print (bidder.avg_utility[t])
#print ("Probability vector before computing estimated loss")
#print bidder.pi
if bidder.pi[arm_chosen] < 0.0000000001:
bidder.pi[arm_chosen] = 0.0000000001
#estimated_loss = bidder.avg_utility[t][arm_chosen]/bidder.pi[arm_chosen]
estimated_loss = (bidder.avg_utility[t][arm_chosen] -
bidder.beta) / bidder.pi[arm_chosen]
#print ("Estimated Loss")
#print estimated_loss
bidder.loss[arm_chosen] += estimated_loss
#print bidder.loss
bidder.weights = [
math.exp(-bidder.eta_gexp3 * bidder.loss[b])
for b in range(0, bidder.bid_space)
]
bidder.pi = [(1 - gamma) * bidder.weights[b] / sum(bidder.weights) +
gamma / bidder.bid_space
for b in range(0, bidder.bid_space)]
#print ("Probability vector after computing estimated loss")
#print bidder.pi
# compute the algorithm's utility at every step
#algo_util.append(bidder.avg_utility[t][int(math.ceil(bids[0][t][bidder.id]/bidder.eps))])
algo_util.append(bidder.avg_utility[t][int(
math.ceil(bids[0][t][0] / bidder.eps))])
#print ("Algorithm's average utility")
#print algo_util
temp_regr.append(
regret(0, bidder.reward_func, bidder.alloc_func, bidder.bid_space,
algo_util, t, num_auctions))
#print ("Regret inside" )
#print temp_regr
return temp_regr
def main_winexp(bidder, curr_rep, T, num_bidders, num_slots, outcome_space,
rank_scores, ctr, reserve, values, bids, threshold, noise,
num_adaptive):
algo_util = []
temp_regr = []
clean_alloc = [[] for _ in range(0, T)]
for t in range(0, T):
bid_chosen = [bidder[i].bidding() for i in range(0, num_adaptive)]
for i in range(0, num_adaptive):
bids[t][i] = bid_chosen[i]
bid_vec = deepcopy(bids[t])
gsp_instance = GSP(ctr[t], reserve[t], bid_vec, rank_scores[t],
num_slots, num_bidders)
# this is not reported to the bidder, and thus is cleaned of noise
for i in range(0, num_adaptive):
allocated = gsp_instance.alloc_func(bidder[i].id,
bids[t][bidder[i].id])
temp = [
gsp_instance.alloc_func(bidder[i].id, bid * bidder[i].eps)
for bid in range(0, bidder[i].bid_space)
]
if (i == 0):
clean_alloc[t] = deepcopy(temp)
# bidder sees noisy data as his allocation
noise_cp = deepcopy(noise)
bidder[i].alloc_func[t] = noise_mask(temp, noise_cp[t], ctr[t],
num_slots)
#reward function: value - payment(coming from GSP module)
bidder[i].pay_func[t] = [
gsp_instance.pay_func(bidder[i].id, bid * bidder[i].eps)
for bid in range(0, bidder[i].bid_space)
]
#### WIN-EXP computations ####
# computation of reward will only be used for the regret
if (i == 0):
if allocated > threshold[t]:
bidder[i].reward_func[t] = [
(values[t][0] - bidder[i].pay_func[t][b])
for b in range(0, bidder[i].bid_space)
]
bidder[i].utility[t] = bidder[i].compute_utility(
1, bidder[i].reward_func[t], bidder[i].alloc_func[t])
else:
bidder[i].reward_func[t] = [
0 for _ in range(0, bidder[i].bid_space)
]
bidder[i].utility[t] = (bidder[i].compute_utility(
0, bidder[i].reward_func[t], bidder[i].alloc_func[t]))
(bidder[i].weights,
bidder[i].pi) = bidder[i].weights_update_winexp(
bidder[i].eta_winexp, bidder[i].utility[t])
else:
if allocated > threshold[t]:
bidder[i].reward_func[t] = [
(values[t][i] - bidder[i].pay_func[t][b])
for b in range(0, bidder[i].bid_space)
]
else:
bidder[i].reward_func[t] = [
0 for _ in range(0, bidder[i].bid_space)
]
bidder[i].utility[t] = bidder[i].reward_func[t]
#weights update
arm_chosen = int(math.ceil(bids[t][i] / bidder[i].eps))
if bidder[i].pi[arm_chosen] < np.exp(-700):
bidder[i].pi[arm_chosen] = np.exp(-700)
estimated_loss = -bidder[i].utility[t][arm_chosen] / bidder[
i].pi[arm_chosen]
bidder[i].loss[arm_chosen] += estimated_loss
arr = np.array([(-bidder[i].eta_exp3) * bidder[i].loss[b]
for b in range(0, bidder[i].bid_space)],
dtype=np.float128)
bidder[i].weights = np.exp(arr)
bidder[i].pi = [
bidder[i].weights[b] / sum(bidder[i].weights)
for b in range(0, bidder[i].bid_space)
]
# for each auction (at the same t) you choose the same arm
arm = int(math.ceil(bids[t][0] / bidder[0].eps))
algo_util.append((bidder[0].reward_func[t][arm] * clean_alloc[t][arm]))
temp_regr.append(
regret(bidder[0].reward_func, clean_alloc, bidder[0].bid_space,
algo_util, t))
return temp_regr
def bid_range(slot, reserve):
return GSP.bid_range_for_slot(slot, slot_clicks, reserve, bids)
from gsp import GSP threshold = 5 # minimum support level = 3 # number of levels for GSP g = GSP(threshold, './Data_GSP/') g.get_support_items(level)
def bid_range(slot, reserve):
return GSP.bid_range_for_slot(slot, slot_clicks, reserve, bids)