用Python模拟信号博弈：从厂商进入案例到代码实现

博弈论作为分析策略互动的强大工具，在经济学和商业决策中有着广泛应用。信号博弈作为不完全信息动态博弈的典型代表，常被用于分析市场进入、招聘筛选等现实场景。本文将带您用Python构建完整的信号博弈模型，通过代码实现厂商进入案例的动态模拟，直观展现精炼贝叶斯均衡的形成条件。

1. 信号博弈基础与厂商进入模型

信号博弈的核心在于信息不对称——一方拥有私有信息（发送者），另一方通过观察行为信号做出判断（接收者）。在厂商进入案例中：

• 发送者 ：潜在进入厂商（类型θ∈{强θs,弱θw}）
• 接收者 ：已在位厂商
• 信号 ：进入者选择释放的信号强度S/W
• 行动 ：在位者选择对抗F或接纳A

收益矩阵可表示为：

import numpy as np

# 定义博弈参数
types = ['strong', 'weak']  # 进入者类型
signals = ['S', 'W']        # 可发送信号
actions = ['A', 'F']        # 在位者行动

# 收益函数定义
def payoff(entrant_type, signal, action):
    if entrant_type == 'strong':
        if action == 'A': return (3, 1)
        else: return (1, 0)
    else:
        if action == 'A': return (2, 1)
        else: return (0, 2)

2. 信念系统与策略空间建模

精炼贝叶斯均衡要求信念与策略相互一致。我们需要构建：

1. 进入者策略 ：类型到信号的映射
2. 在位者信念 ：观察到信号后对类型的概率判断
3. 在位者策略 ：信号到行动的映射

# 进入者策略类
class EntrantStrategy:
    def __init__(self, strong_signal, weak_signal):
        self.strong_signal = strong_signal  # 强类型发送的信号
        self.weak_signal = weak_signal      # 弱类型发送的信号
    
    def get_signal(self, entrant_type):
        return self.strong_signal if entrant_type == 'strong' else self.weak_signal

# 在位者信念系统
class BeliefSystem:
    def __init__(self, prob_S_strong, prob_W_strong):
        self.prob = {
            'S': prob_S_strong,  # P(θs|S)
            'W': prob_W_strong   # P(θs|W)
        }
    
    def update_belief(self, signal, new_prob):
        self.prob[signal] = new_prob

# 在位者策略类
class IncumbentStrategy:
    def __init__(self, S_action, W_action):
        self.S_action = S_action  # 观察到S时的行动
        self.W_action = W_action  # 观察到W时的行动
    
    def get_action(self, signal):
        return self.S_action if signal == 'S' else self.W_action

3. 均衡验证与可视化分析

通过迭代验证不同策略组合下的均衡条件，我们可以找到精炼贝叶斯均衡。关键步骤包括：

1. 计算在位者的最优反应
2. 检查进入者是否有动机偏离
3. 验证信念的一致性

def check_pbe(entrant_strategy, incumbent_strategy, belief_system, p):
    # 检查在位者策略是否最优
    for signal in signals:
        expected_payoff = {}
        for action in actions:
            # 计算期望收益
            prob_strong = belief_system.prob[signal]
            strong_payoff = payoff('strong', signal, action)[1]
            weak_payoff = payoff('weak', signal, action)[1]
            expected_payoff[action] = prob_strong*strong_payoff + (1-prob_strong)*weak_payoff
        
        # 验证当前策略是否为最优
        optimal_action = max(expected_payoff, key=expected_payoff.get)
        current_action = incumbent_strategy.get_action(signal)
        if optimal_action != current_action:
            return False
    
    # 检查进入者是否有动机偏离
    for entrant_type in types:
        current_signal = entrant_strategy.get_signal(entrant_type)
        current_action = incumbent_strategy.get_action(current_signal)
        current_entrant_payoff = payoff(entrant_type, current_signal, current_action)[0]
        
        # 尝试所有可能的偏离信号
        for alt_signal in signals:
            if alt_signal == current_signal:
                continue
            alt_action = incumbent_strategy.get_action(alt_signal)
            alt_payoff = payoff(entrant_type, alt_signal, alt_action)[0]
            if alt_payoff > current_entrant_payoff:
                return False
    
    # 验证信念的一致性
    if entrant_strategy.strong_signal == 'S' and entrant_strategy.weak_signal == 'W':
        if not (np.isclose(belief_system.prob['S'], 1) and np.isclose(belief_system.prob['W'], 0)):
            return False
    # 其他策略组合的信念验证...
    
    return True

4. 完整模拟与参数敏感性分析

通过系统性地改变先验概率p，我们可以观察均衡如何随参数变化：

import matplotlib.pyplot as plt

# 模拟不同p值下的均衡
p_values = np.linspace(0, 1, 100)
equilibrium_types = []

for p in p_values:
    # 尝试不同的策略组合
    if p > 0.5:
        # 可能形成混同均衡
        entrant_strategy = EntrantStrategy('S', 'S')
        belief_system = BeliefSystem(p, 0.5)  # 非均衡路径信念任意
        incumbent_strategy = IncumbentStrategy('A', 'A')
        if check_pbe(entrant_strategy, incumbent_strategy, belief_system, p):
            equilibrium_types.append('Pooling (SS)')
            continue
    
    # 检查其他可能的均衡...
    equilibrium_types.append('Separating (SW)')

# 可视化结果
plt.figure(figsize=(10, 6))
plt.plot(p_values, [1 if eq == 'Pooling (SS)' else 0 for eq in equilibrium_types], 
         label='Pooling Equilibrium')
plt.plot(p_values, [1 if eq == 'Separating (SW)' else 0 for eq in equilibrium_types],
         label='Separating Equilibrium')
plt.xlabel('Prior Probability p (P(θ=strong))')
plt.ylabel('Equilibrium Type')
plt.title('Equilibrium Types vs Prior Probability')
plt.legend()
plt.grid(True)
plt.show()

5. Jupyter Notebook实战技巧

在实际分析中，交互式探索非常关键。以下是几个实用技巧：

1. 动态参数调节 ：使用IPython widgets创建交互控件

   from ipywidgets import interact
   
   @interact(p=(0, 1, 0.01))
   def analyze_equilibrium(p=0.5):
       # 动态分析特定p值下的均衡
       ...
   

2. 收益矩阵可视化

   import seaborn as sns
   
   payoff_matrix = np.array([
       [payoff('strong', 'S', 'A'), payoff('strong', 'S', 'F')],
       [payoff('weak', 'W', 'A'), payoff('weak', 'W', 'F')]
   ])
   sns.heatmap(payoff_matrix, annot=True, fmt='.1f')
   

3. 博弈树绘制 ：使用networkx展示决策路径

   import networkx as nx
   
   G = nx.DiGraph()
   # 构建博弈树节点和边
   ...
   pos = nx.spring_layout(G)
   nx.draw(G, pos, with_labels=True)
   

通过完整的代码实现和可视化分析，我们可以直观理解信号博弈中信息传递的机制，以及不同类型均衡形成的条件。这种将理论模型转化为可执行代码的方法，不仅加深了对博弈论概念的理解，也为实际商业决策提供了可操作的模拟工具。