Python gsp.GSP类代码示例

    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 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 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)

 def bid_range(slot, reserve):
     return GSP.bid_range_for_slot(slot, slot_clicks, reserve, bids)