Python实现CBAA拍卖算法（一）

最新推荐文章于 2025-03-03 16:35:24 发布

矢志航天的阿洪

最新推荐文章于 2025-03-03 16:35:24 发布

阅读量1.3k

点赞数 22

文章标签：算法

本文链接：https://blog.csdn.net/weixin_57997461/article/details/144794850

版权

一、背景介绍

本节意在复现<Consensus-Based Decentralized Auctions for Robust Task Allocation>提出的两种分散式算法：consensus-based auction algorithm(CBAA)和consensus-based bundle algorithm(CBBA)。

二、问题介绍

假设存在A、B、C三个用户和三件商品足球、篮球、乒乓球。由于三个人的爱好不一样，因此三件商品在其心目中的价值不一样，例如A对三件商品的价值估计分别为5，2，0，B和C分别为1，4，1；4，3，2。求出使得三个人同时满足最大收获的分配方法。

三、求解思路

根据文献提出的方法，CBAA方法基于所有人共识，从自私的角度出发，对于A来说，足球是最值得买的，因此，A选择了足球A，作为自己想买的，并根据其价值提出5元，同理B和C分别选择篮球和足球，并各自提出自己的竞标价格为4元和4元，此时，A和C发生了冲突，因为对于商家来说，A出价更高，所以A获得了足球，此时C选择篮球，提出3元购买，但是B出价高，因此只剩下乒乓球留给C。

四、算法及代码

根据数学语言，将上述过程描述，需要引入以下几个符号

$\boldsymbol{x}_{ij}$ ：描述用户i和商品j的对应关系，如果用户i选择了j商品，那么为1，否则为0。

$\boldsymbol{y}_{ij}$ ：描述用户i对商品j竞标提出的价格。

$\boldsymbol{J}_{i}$ ：描述商品i被分配给的用户。

$\boldsymbol{z}_{ij}$ ：描述用户i竞标成功的商品。

$\boldsymbol{g}_{ij}$ ：描述用户i和用户j之间是否存在联系，即自己提出的价格，别人是否知晓。

$\boldsymbol{c}_{ij}$ ：描述用户i对商品j的价值估计

分为两个阶段，第一阶段是拍卖竞标阶段，每个人基于自己估计的价值选择商品，初始竞标价格均为0元，以用户A为例， $\boldsymbol{y}_{1j}=\left [ 0,0,0 \right ]$ ， $\boldsymbol{c}_{1j}=\left [ 5,2,0 \right ]$ ，首先找到A用户可以买到的物品并且希望找到对于自己来说价值最高的目标，Python代码如下所示：

def h_compute(c,y):          
    h = np.zeros(len(c))     
    for i in range(len(c)):  
        if c[i] > y[i]:      
            h[i] = 1         
        else:                
            h[i] = 0         
    return h

def Select_Task(c,x,y,J,z,i):                         
    if sum(x) == 0:                                   
        h = h_compute(c,y)                            
        if sum(h) != 0: #如果这里有合适的任务                   
            max_valid_c = -1                          
            for j in range(len(y)):                   
                # 找到估计价值最高的商品                         
                if h[j] == 1 and c[j] > max_valid_c:  
                    J = j                             
                    max_valid_c = c[j]                
            #  拍卖该目标                                  
            x[J] = 1                                  
            z[J] = i                                  
            y[J] = c[J]                               
    return x,y,J,z

原文里面的流程图

当完成竞拍后，由于拍卖方希望以最大的收获卖出去，所以对于同一件商品，谁给的钱最多，相应的商品会分配给谁，即共识阶段。例如：对于用户C来说，他本身也希望获得足球，但是他给出的价格只能是4元，大家互相之间首先得了解各自对该商品的报价，即在本文讨论的案例中，对于任意i和j，满足 $\boldsymbol{g}_{ij}=1$ 。例如完成第一阶段的A，商家对于各个物品的报价是[5,0,0]，对于B来说，其对于各个物品的报价是[5,4,0]，对于C来说，是[5,4,0]。在该阶段之后开始分配，此时足球暂时归A，篮球暂时归B，C竞标失败没有分配到商品。商家对于各个物品的报价为[5,4,0]，开始第二轮竞标，此时，判断是否所有人分配到商品，对于C来说，足球和篮球的报价均超过其估计范围，因此只能选择乒乓球，完成任务分配。

第二部分算法的流程图

def  Update_Task(g,c,x,y,J,z,i):                                     
    # 此时的y是矩阵                                                        
    new_y = copy.deepcopy(y)                                         
    # 根据其他竞标人的价格更新出价                                                 
    for j in range(len(y[0])):                                       
        for k in range(len(g)):     # 有联系的才更新                        
            if g[k] == 1:                                            
                if y[k][j] > new_y[i][j]:                            
                    new_y[i][j] = y[j][k]                            
    max_y =  y[i][J[i]]                                              
    # 更新邻居的竞标信息                                                      
    for k in range(len(g)):                                          
        if g[k] == 1:                                                
            if y[k][J[i]] > max_y:                                   
                z[i][J[i]] = k                                       
                max_y = y[k][J[i]]                                   
                                                                     
    if z[i][J[i]] != i:                                              
        x[J[i]] = 0                                                  
    """                                                              
    当存在相同商品 多用户出价一样的情况下，这个任务分配给索引更大的用户                               
    """                                                              
    for k in range(len(g)):                                          
        for j in range(len(y[0])):                                   
            if g[k] == 1:                                            
                if z[k][j] > z[i][j] and c[k][j] == c[i][j]:         
                    if J[i] == j:                                    
                        x[j] == 0                                    
                    z[i][j] = z[k][j]                                
    return x,new_y,J[i],z

整个代码框架

import numpy as np
import copy

def CBAA_self(N_a,N_t,c,g):
    x = np.zeros((3,3))
    y = np.zeros((3,3))
    z = np.full((3,3),-1)
    # 使用列表的方式添加元素

    J = np.full((3,1),-1)
    x_history = []
    while True:
        for i in range(N_a):
            x[i],y[i],J[i],z[i] = Select_Task(c[i],x[i],y[i],J[i],z[i],i)
            x[i],y,J[i],z       = Update_Task(g[i],c,x[i],y,J,z,i)
        x_history.append(copy.deepcopy(x))
        if np.all(np.sum(x,axis=0)==1):
            break
    return x_history


def h_compute(c,y):
    h = np.zeros(len(c))
    for i in range(len(c)):
        if c[i] > y[i]:
            h[i] = 1
        else:
            h[i] = 0
    return h

def Select_Task(c,x,y,J,z,i):
    if sum(x) == 0:
        h = h_compute(c,y)
        if sum(h) != 0: #如果这里有合适的任务
            max_valid_c = -1
            for j in range(len(y)):
                # 找到估计价值最高的商品
                if h[j] == 1 and c[j] > max_valid_c:
                    J = j
                    max_valid_c = c[j]
            #  拍卖该目标
            x[J] = 1
            z[J] = i
            y[J] = c[J]
    return x,y,J,z

def  Update_Task(g,c,x,y,J,z,i):
    # 此时的y是矩阵
    new_y = copy.deepcopy(y)
    # 根据其他竞标人的价格更新出价
    for j in range(len(y[0])):
        for k in range(len(g)):     # 有联系的才更新
            if g[k] == 1:
                if y[k][j] > new_y[i][j]:
                    new_y[i][j] = y[j][k]
    max_y =  y[i][J[i]]
    # 更新邻居的竞标信息
    for k in range(len(g)):
        if g[k] == 1:
            if y[k][J[i]] > max_y:
                z[i][J[i]] = k
                max_y = y[k][J[i]]

    if z[i][J[i]] != i:
        x[J[i]] = 0
    """
    当存在相同商品 多用户出价一样的情况下，这个任务分配给索引更大的用户
    """
    for k in range(len(g)):
        for j in range(len(y[0])):
            if g[k] == 1:
                if z[k][j] > z[i][j] and c[k][j] == c[i][j]:
                    if J[i] == j:
                        x[j] == 0
                    z[i][j] = z[k][j]
    return x,new_y,J[i],z





if __name__ == "__main__":
    N_a = 3
    N_t = 3
    c   = np.array([[5,2,0],[1,4,1],[4,3,2]])
    g   = np.ones((3,3))
    x_history = CBAA_self(N_a, N_t, c, g)  #
    print(x_history[-1])  #