当前位置：首页 > article >正文

【复杂网络演化博弈_01】理论部分+代码应用

article 2025/1/10 0:57:57

复杂网络演化博弈

一、理论部分
- （1）研究背景
- （2）群体合作困境
- （3）核心要素
- （4）网络模型
- - 1、规则网络
  - 2、随机网络
  - 3、小世界网络
  - 4、无标度网络
二、网络博弈的进展
- （1）1992年提出的网络化系统博弈理论介绍
- （2）2006年的bck判据
- （3）2017年异质网络临界值判据
- （4）系统结构的时空复杂性
- - 1、有向性
  - 2、高阶性
  - 3、多层性
  - 4、动态性
三、代码部分
- （1）模型一：囚徒困境博弈+费米学习策略+环形规则网络
- （2）网络博弈过程中的随机干扰
- - 1、策略随机变更
  - 2、重新连边

一、理论部分

（1）研究背景

在这里插入图片描述

（2）群体合作困境

例子一： 通过下面的囚徒困境可以看出，当参与者A采取不捐赠的行为时，其所带来的收益总是大于采取捐赠行为所带来的收益。

例子二： 如下图的网络演化来说，当有一个个体采取了不捐赠行为，会导致其周围的个体也有一定的几率采取不捐赠的行为。最终导致所有的个体都不合作。

结论： 个体最大化自身利益动机导致了群体合作困境。

在这里插入图片描述

经典的囚徒困境博弈的收益矩阵一般是这样的：
在这里插入图片描述
其中里面的收益参数表示玩家在面对不同玩家策略时所获得的收益。一般满足T>R>P>S和2R>T+S，以确保每个玩家都面临合作与背叛之间的决策。

（3）核心要素

复杂网络演化博弈的核心有三个要素：博弈模型、学习策略以及网络模型。学习策略这里暂不对其它策略进行探讨，只采用常规的费米规则。

（4）网络模型

网络由节点和连接节点的边组成，例如社交关系网络、交通网络、互联网等。最常见的基本网络模型有规则网络、随机网络、小世界网络和无标度网络。其中关于这些网络的理论和构建，主要是根据Watts、Strogatz、Barabási、Albert等人的研究。

1、规则网络

规则网络是最简单的网络模型，常见的规则网络有：（1）环形网络。最简单的规则网络之一；（2）方格网络。其中有二维方格网络和多维方格网络，例如在三维的网络中，每个节点可以与其六个邻居（上下左右前后）连接。（3）最近邻耦合网络。局部性较强，连通性依赖近邻的直接连接。当然还有星形网络等多种规则网络。

2、随机网络

随机网络是由一些节点通过随机连接而组成的一种复杂网络。随机网络的生成有两种等价方法：（1）给定N个节点，网络中的每对节点之间以概率连接。（2）给定N个节点和M条边，随机选择M对节点并在它们之间创建边。

3、小世界网络

小世界特征是具有较短的平均路径长度和较大的聚类系数。WS小世界网络的构造是从规则图开始，基于概率P随机重连。在WS小世界网络的基础上又衍生出了NW小世界网络等多个网络变体模型。

4、无标度网络

现实中大多网络是无标度的。当节点度非常大时，网络的度分布遵循幂律分布。其中无标度网络的关键在于增长和优先连接。

二、网络博弈的进展

此处重点介绍三个理论研究：
（1）1992年提出的网络化系统博弈
（2）网络化系统博弈策略占优判据
（3）异构网络化系统博弈
在这里插入图片描述

（1）1992年提出的网络化系统博弈理论介绍

下面这四张图片当中红色的方块代表有进行群体合作。随着网络演化，红色的方块并没有消失，这表明网络结构是维持网络合作的原因。

在这里插入图片描述

（2）2006年的bck判据

在这里插入图片描述

（3）2017年异质网络临界值判据

在这里插入图片描述

（4）系统结构的时空复杂性

在这里插入图片描述

1、有向性

在这里插入图片描述

2、高阶性

在这里插入图片描述

3、多层性

在这里插入图片描述

4、动态性

在这里插入图片描述

三、代码部分

（1）模型一：囚徒困境博弈+费米学习策略+环形规则网络

根据第一部分所说的复杂网络演化博弈所需要的三要素

博弈模型：囚徒困境博弈
学习策略：费米学习策略
网络模型：环形规则网络

在这里插入图片描述

clear;
tic

% 参数定义
N = 100;           % 网络节点数
num_iterations = 100;  % 迭代次数
num_simulations = 100;  % 蒙特卡洛模拟次数

% 不同背叛收益T值下的调用
GZ1_Result1 = GZ1(N, 0.5, 1.0, 0, -0.5, num_iterations, num_simulations);  
GZ1_Result2 = GZ1(N, 1.0, 1.0, 0, -0.5, num_iterations, num_simulations);  
GZ1_Result3 = GZ1(N, 1.5, 1.0, 0, -0.5, num_iterations, num_simulations); 

% 结果展示
figure(1); box on; hold on;
plot(mean(GZ1_Result1, 1), 'linewidth', 1.5, 'Color', 'b');
plot(mean(GZ1_Result2, 1), 'linewidth', 1.5, 'Color', 'r');
plot(mean(GZ1_Result3, 1), 'linewidth', 1.5, 'Color', 'g');
legend('T=0.5', 'T=1.0', 'T=1.5');
xlabel('迭代次数');
ylabel('合作者占比');
ylim([0 1.05]);
title('不同背叛收益 T 下的合作策略演化 (蒙特卡洛模拟)');

toc;

function strategies_avg = GZ1(N, T, R, P, S, num_iterations, num_simulations)
    % 初始化策略记录
    strategies_all = zeros(num_simulations, num_iterations);

    for sim = 1:num_simulations
        num_cooperators = round(0.5 * N);  % 合作者数量
        strategies = zeros(N, 1);
        strategies(1:num_cooperators) = 1;  % 设定初始合作者
        strategies = strategies(randperm(N));  % 随机打乱策略分布
        
        % 创建环形规则网络
        neighbors = zeros(N, 2);
        for i = 1:N
            if i == 1
                neighbors(i, :) = [N, 2];
            elseif i == N
                neighbors(i, :) = [N-1, 1];
            else
                neighbors(i, :) = [i-1, i+1];
            end
        end
        
        % 记录每次迭代的合作策略比例
        coop_ratio = zeros(1, num_iterations);
        
        % 模拟过程
        for t = 1:num_iterations
            % 随机选择一个节点
            i = randi(N);

            % 计算节点i的支付
            payoff_i = 0;
            for neighbor = neighbors(i, :)
                if strategies(i) == 0 && strategies(neighbor) == 1
                    payoff_i = payoff_i + T;
                elseif strategies(i) == 1 && strategies(neighbor) == 1
                    payoff_i = payoff_i + R;
                elseif strategies(i) == 0 && strategies(neighbor) == 0
                    payoff_i = payoff_i + P;
                elseif strategies(i) == 1 && strategies(neighbor) == 0
                    payoff_i = payoff_i + S;
                end
            end

            % 选择一个邻居j
            j = neighbors(i, randi(2));
            
            % 计算邻居j的支付
            payoff_j = 0;
            for neighbor = neighbors(j, :)
                if strategies(j) == 0 && strategies(neighbor) == 1
                    payoff_j = payoff_j + T;
                elseif strategies(j) == 1 && strategies(neighbor) == 1
                    payoff_j = payoff_j + R;
                elseif strategies(j) == 0 && strategies(neighbor) == 0
                    payoff_j = payoff_j + P;
                elseif strategies(j) == 1 && strategies(neighbor) == 0
                    payoff_j = payoff_j + S;
                end
            end

            % 费米学习规则
            probability = 1 / (1 + exp((payoff_i - payoff_j) / 0.1)); % 假设温度参数为0.1
            if rand() < probability
                strategies(i) = strategies(j);
            end
            
            % 记录当前迭代的合作策略比例
            coop_ratio(t) = sum(strategies) / N;
        end
        
        % 存储每次模拟的合作策略比例
        strategies_all(sim, :) = coop_ratio;
    end
    
    % 计算每次迭代的平均合作策略比例
    strategies_avg = mean(strategies_all, 1);
end

得到运行结果：

在这里插入图片描述

（2）网络博弈过程中的随机干扰

随机干扰通常用于模拟现实世间中不确定性和偶然性对系统行为的影响。

我们主要讨论两个基础的随机干扰情况：策略随机变更和重新连边。

1、策略随机变更

clear;
tic

% 参数定义
N = 100; % 网络节点数
num_iterations = 100; % 迭代次数
num_simulations = 100; % 蒙特卡洛模拟次数
mutation_probs = [0.01, 0.1, 1]; % 策略变更概率

% 不同背叛收益T值下的调用
T_values = [0.5, 1.0, 1.5];

figure; % 创建一个新的图形窗口

for m = 1:length(mutation_probs)
    mutation_prob = mutation_probs(m);
    
    GZ1_Result1 = GZ1(N, T_values(1), 1.0, 0, -0.5, num_iterations, num_simulations, mutation_prob);
    GZ1_Result2 = GZ1(N, T_values(2), 1.0, 0, -0.5, num_iterations, num_simulations, mutation_prob);
    GZ1_Result3 = GZ1(N, T_values(3), 1.0, 0, -0.5, num_iterations, num_simulations, mutation_prob);

    % 创建子图
    subplot(length(mutation_probs), 1, m); % 创建一个 m 行 1 列的子图
    box on; hold on;
    plot(mean(GZ1_Result1, 1), 'linewidth', 1.5, 'Color', 'b');
    plot(mean(GZ1_Result2, 1), 'linewidth', 1.5, 'Color', 'r');
    plot(mean(GZ1_Result3, 1), 'linewidth', 1.5, 'Color', 'g');
    legend('T=0.5', 'T=1.0', 'T=1.5');
    xlabel('迭代次数');
    ylabel('合作者占比');
    ylim([0 1.05]);
    title(['策略变更概率 = ', num2str(mutation_prob)]);
end

toc;

function strategies_avg = GZ1(N, T, R, P, S, num_iterations, num_simulations, mutation_prob)
% 初始化策略记录
strategies_all = zeros(num_simulations, num_iterations);

for sim = 1:num_simulations
    num_cooperators = round(0.5 * N); % 合作者数量
    strategies = zeros(N, 1);
    strategies(1:num_cooperators) = 1; % 设定初始合作者
    strategies = strategies(randperm(N)); % 随机打乱策略分布

    % 创建环形规则网络
    neighbors = zeros(N, 2);
    for i = 1:N
        if i == 1
            neighbors(i, :) = [N, 2];
        elseif i == N
            neighbors(i, :) = [N-1, 1];
        else
            neighbors(i, :) = [i-1, i+1];
        end
    end

    % 记录每次迭代的合作策略比例
    coop_ratio = zeros(1, num_iterations);

    % 模拟过程
    for t = 1:num_iterations
        % 随机选择一个节点
        i = randi(N);

        % 计算节点i的支付
        payoff_i = 0;
        for neighbor = neighbors(i, :)
            if strategies(i) == 0 && strategies(neighbor) == 1
                payoff_i = payoff_i + T;
            elseif strategies(i) == 1 && strategies(neighbor) == 1
                payoff_i = payoff_i + R;
            elseif strategies(i) == 0 && strategies(neighbor) == 0
                payoff_i = payoff_i + P;
            elseif strategies(i) == 1 && strategies(neighbor) == 0
                payoff_i = payoff_i + S;
            end
        end

        % 选择一个邻居j
        j = neighbors(i, randi(2));

        % 计算邻居j的支付
        payoff_j = 0;
        for neighbor = neighbors(j, :)
            if strategies(j) == 0 && strategies(neighbor) == 1
                payoff_j = payoff_j + T;
            elseif strategies(j) == 1 && strategies(neighbor) == 1
                payoff_j = payoff_j + R;
            elseif strategies(j) == 0 && strategies(neighbor) == 0
                payoff_j = payoff_j + P;
            elseif strategies(j) == 1 && strategies(neighbor) == 0
                payoff_j = payoff_j + S;
            end
        end

        % 费米学习规则
        probability = 1 / (1 + exp((payoff_i - payoff_j) / 0.1)); % 假设温度参数为0.1
        if rand() < probability
            strategies(i) = strategies(j);
        end

        % 策略随机变更
        for k = 1:N
            if rand() < mutation_prob
                strategies(k) = 1 - strategies(k); % 变更策略
            end
        end

        % 记录当前迭代的合作策略比例
        coop_ratio(t) = sum(strategies) / N;
    end

    % 存储每次模拟的合作策略比例
    strategies_all(sim, :) = coop_ratio;
end

% 计算每次迭代的平均合作策略比例
strategies_avg = mean(strategies_all, 1);
end

在这里插入图片描述
如果不用子图的形式，是长下面这样的：

2、重新连边

clear;
tic

% 参数定义
N = 100; % 网络节点数
num_iterations = 100; % 迭代次数
num_simulations = 100; % 蒙特卡洛模拟次数
rewiring_probs = [0.01, 0.1, 1]; % 重新连边概率

% 不同背叛收益T值下的调用
T_values = [0.5, 1.0, 1.5];

figure; % 创建一个新的图形窗口

for m = 1:length(rewiring_probs)
    rewiring_prob = rewiring_probs(m);
    
    GZ1_Result1 = GZ1(N, T_values(1), 1.0, 0, -0.5, num_iterations, num_simulations, rewiring_prob);
    GZ1_Result2 = GZ1(N, T_values(2), 1.0, 0, -0.5, num_iterations, num_simulations, rewiring_prob);
    GZ1_Result3 = GZ1(N, T_values(3), 1.0, 0, -0.5, num_iterations, num_simulations, rewiring_prob);

    % 创建子图
    subplot(length(rewiring_probs), 1, m); % 创建一个 m 行 1 列的子图
    box on; hold on;
    plot(mean(GZ1_Result1, 1), 'linewidth', 1.5, 'Color', 'b');
    plot(mean(GZ1_Result2, 1), 'linewidth', 1.5, 'Color', 'r');
    plot(mean(GZ1_Result3, 1), 'linewidth', 1.5, 'Color', 'g');
    legend('T=0.5', 'T=1.0', 'T=1.5');
    xlabel('迭代次数');
    ylabel('合作者占比');
    ylim([0 1.05]);
    title(['重新连边概率 = ', num2str(rewiring_prob)]);
end

toc;

function strategies_avg = GZ1(N, T, R, P, S, num_iterations, num_simulations, rewiring_prob)
% 初始化策略记录
strategies_all = zeros(num_simulations, num_iterations);

for sim = 1:num_simulations
    num_cooperators = round(0.5 * N); % 合作者数量
    strategies = zeros(N, 1);
    strategies(1:num_cooperators) = 1; % 设定初始合作者
    strategies = strategies(randperm(N)); % 随机打乱策略分布

    % 创建环形规则网络
    neighbors = zeros(N, 2);
    for i = 1:N
        if i == 1
            neighbors(i, :) = [N, 2];
        elseif i == N
            neighbors(i, :) = [N-1, 1];
        else
            neighbors(i, :) = [i-1, i+1];
        end
    end

    % 记录每次迭代的合作策略比例
    coop_ratio = zeros(1, num_iterations);

    % 模拟过程
    for t = 1:num_iterations
        % 随机选择一个节点
        i = randi(N);

        % 计算节点i的支付
        payoff_i = 0;
        for neighbor = neighbors(i, :)
            if strategies(i) == 0 && strategies(neighbor) == 1
                payoff_i = payoff_i + T;
            elseif strategies(i) == 1 && strategies(neighbor) == 1
                payoff_i = payoff_i + R;
            elseif strategies(i) == 0 && strategies(neighbor) == 0
                payoff_i = payoff_i + P;
            elseif strategies(i) == 1 && strategies(neighbor) == 0
                payoff_i = payoff_i + S;
            end
        end

        % 选择一个邻居j
        j = neighbors(i, randi(2));

        % 计算邻居j的支付
        payoff_j = 0;
        for neighbor = neighbors(j, :)
            if strategies(j) == 0 && strategies(neighbor) == 1
                payoff_j = payoff_j + T;
            elseif strategies(j) == 1 && strategies(neighbor) == 1
                payoff_j = payoff_j + R;
            elseif strategies(j) == 0 && strategies(neighbor) == 0
                payoff_j = payoff_j + P;
            elseif strategies(j) == 1 && strategies(neighbor) == 0
                payoff_j = payoff_j + S;
            end
        end

        % 费米学习规则
        probability = 1 / (1 + exp((payoff_i - payoff_j) / 0.1)); % 假设温度参数为0.1
        if rand() < probability
            strategies(i) = strategies(j);
        end

        % 重新连边
        for k = 1:N
            if rand() < rewiring_prob
                % 随机选择一个新的邻居
                new_neighbor = randi(N);
                while new_neighbor == k || ismember(new_neighbor, neighbors(k, :))
                    new_neighbor = randi(N);
                end
                % 随机替换一个邻居
                replace_idx = randi(2);
                neighbors(k, replace_idx) = new_neighbor;
            end
        end

        % 记录当前迭代的合作策略比例
        coop_ratio(t) = sum(strategies) / N;
    end

    % 存储每次模拟的合作策略比例
    strategies_all(sim, :) = coop_ratio;
end

% 计算每次迭代的平均合作策略比例
strategies_avg = mean(strategies_all, 1);
end