企业官网建设流程全解析

1. 项目概述：从社交网络到信息传播的量化洞察

最近几年，无论是品牌营销、舆情监控，还是产品冷启动，大家越来越关注一个核心问题：一条信息（比如一个热点话题、一个产品功能、一则新闻）是如何在人群中扩散开来的？它的传播路径是怎样的？最终能触达多少人？这些问题，本质上就是社交网络中的信息传播问题。单纯靠经验直觉去判断，往往不准，这时候就需要一些数学模型来帮忙了。这个项目，就是带你亲手搭建几个经典的信息传播模型，并用Python把它们实现出来，让你能直观地看到信息扩散的动态过程。

简单来说，信息传播模型就是一套数学规则，用来模拟个体（网络中的节点）在受到邻居影响后，其状态（比如从未知到知晓，从知晓到传播，再到遗忘）如何发生变化。通过计算机模拟成千上万次这样的个体互动，我们就能预测整个网络的宏观传播效果。这对于评估营销活动的潜在影响力、预测舆情走势、甚至分析传染病扩散，都有极大的参考价值。无论你是做数据分析、产品运营，还是策略研究，掌握这套方法都能让你多一个强有力的量化分析工具。

2. 核心模型原理与选型逻辑

信息传播模型有很多种，选择哪个取决于你想模拟的现实场景。这次我们重点实现三个最基础、也最经典的模型：SI、SIR和IC模型。它们各有侧重，构成了理解更复杂模型的基础。

2.1 SI模型：最简单的扩散起点

SI模型是所有传播模型的“始祖”，它把人群分为两类：易感者（Susceptible, S）和感染者（Infected, I）。在信息传播的语境下，S代表还没听说过这条信息的人，I代表已经知道并会主动传播这条信息的人。模型规则极其简单：一个I状态的节点，每次与它的S状态邻居接触时，都有一定的概率（记为β）将这个邻居转变为I状态。一旦变成I，就永久保持这个状态，不会再变回S。

这个模型模拟的是一种“一旦知晓，永久传播”的场景，比如某些根深蒂固的观念或者常识的普及。它的核心方程是微分方程形式：dI/dt = β * S * I / N，其中N是总人数。这个方程描述了感染者数量随时间增长的速率。选择SI模型作为起点，是因为它逻辑清晰，参数少（只有一个感染概率β），非常适合用来理解传播动力学的基本框架和编程实现的核心循环。

注意：SI模型预测的最终结果是所有人都被感染（I→N），这显然不符合大多数信息传播会饱和的现实。因此，它更适用于理论教学和模拟传播初期阶段。

2.2 SIR模型：引入“免疫”与遗忘

SIR模型在SI的基础上增加了一个状态：移除者（Recovered, R）。现在，人群分为三类：易感者（S）、感染者（I）、移除者（R）。新增的规则是：感染者I在以概率β感染易感者S的同时，自身还会以概率γ转变为移除者R。

在信息传播中，R状态可以理解为对信息“免疫”了。这个人可能已经知道了信息但失去了传播兴趣（比如觉得信息过时了），或者彻底忘记了这条信息。关键点在于，变成R后，节点就不再参与后续的传播过程，既不会被感染，也不会感染别人。

这个模型引入了“恢复”机制，使得传播过程有了终结的可能，最终网络中的个体会稳定在S、I、R三个状态的不同比例上，而不会全部变成I。其微分方程组为：

• dS/dt = -β * S * I / N
• dI/dt = β * S * I / N - γ * I
• dR/dt = γ * I

SIR模型非常适合模拟像季节性新闻、短期营销活动这类“热一阵就过”的信息扩散，也经典地用于传染病研究。参数β（感染率）和γ（恢复率）的比值 R0 = β / γ，是一个关键指标，基本决定了疫情能否爆发。

2.3 IC模型：独立级联与影响力最大化

独立级联模型（Independent Cascade, IC）是另一个流派，常用于社交网络影响力传播的研究。它与SIR的“连续时间”视角不同，IC模型是“离散时间步”的。

在IC模型中，每个节点只有两种状态：活跃（Active）和非活跃（Inactive）。活跃节点代表接受了信息并可能传播的人（类似I），非活跃节点代表未知者（类似S）。模型从一小组初始活跃节点（种子节点）开始，按轮次进行：

1. 第0步：种子节点被激活。
2. 第1步：每个在第0步新激活的节点，有一次机会去尝试激活它的每个非活跃邻居。对每个邻居，激活尝试以概率p（一个预设的传播概率）独立成功或失败。
3. 后续步骤：只有在上一步新被激活的节点，才能在当前步尝试激活其邻居。如果一个节点激活尝试失败，或者它在上一步已经被激活但未成功激活任何邻居，它在后续步骤中将不再进行尝试。

这个过程一直持续到没有新的节点被激活为止。IC模型的核心特点是“一次性尝试”和“级联失效”。它模拟了现实中的一种情况：你第一次听到某个消息时可能会转发，但如果这次没转，以后大概率也不会再转了。这个模型是解决“影响力最大化”问题（如何选择k个种子节点使最终激活的节点数最多）的经典基础模型。

3. 环境准备与网络数据构建

在写代码之前，我们需要搭建好实验环境，并准备好模拟的“舞台”——社交网络。

3.1 Python环境与核心库

我强烈建议使用Anaconda来管理Python环境，它能很好地处理科学计算库的依赖。核心库就三个：

• NetworkX： 这是Python中处理复杂网络（图）的“瑞士军刀”。创建网络、添加节点和边、计算网络属性、画图，全都靠它。
• NumPy： 提供高效的数组运算和随机数生成，我们模拟概率事件（比如以概率β感染）离不开它。
• Matplotlib： 用于可视化。我们要画出网络结构图，以及传播过程中各状态人数随时间变化的曲线。

安装非常简单，在终端或Anaconda Prompt里执行：

pip install networkx numpy matplotlib

3.2 构建模拟社交网络

现实中的社交网络数据获取不易，我们先用一个经典的合成网络模型来模拟——WS小世界网络。它由Watts和Strogatz提出，能生成具有较短平均路径长度（六度分隔）和较高聚类系数（朋友的朋友也是朋友）的网络，这非常贴合真实社交网络的特征。

import networkx as nx import matplotlib.pyplot as plt def create_social_network(n=100, k=4, p=0.1): """ 创建一个WS小世界网络，用于模拟社交网络。 参数: n: 网络中的节点数（人数），默认100。 k: 每个节点初始连接的邻居数（必须是偶数），默认4。 p: 每条边被随机重连的概率，控制着网络的“小世界”特性，默认0.1。 返回: G: 一个NetworkX图对象。 """ # 使用networkx的connected_watts_strogatz_graph函数，确保生成的网络是连通的。 G = nx.connected_watts_strogatz_graph(n=n, k=k, p=p) print(f"网络创建成功！节点数：{G.number_of_nodes()}， 边数：{G.number_of_edges()}") print(f"平均聚类系数：{nx.average_clustering(G):.3f}， 平均最短路径长度：{nx.average_shortest_path_length(G):.3f}") return G # 创建一个示例网络 G = create_social_network(n=50, k=4, p=0.1) # 可视化这个网络 plt.figure(figsize=(8, 6)) pos = nx.spring_layout(G, seed=42) # 使用spring布局算法，让图看起来更均匀 nx.draw(G, pos, node_color='lightblue', node_size=200, with_labels=False, edge_color='gray') plt.title("WS小世界网络结构（模拟社交网络）") plt.show()

实操心得：p参数是个关键调节旋钮。p=0时，网络是规则环；p=1时，接近随机网络。p在0.01到0.1之间时，网络能很好地兼具高聚类和短路径的特性。初次实验时，节点数n不要设太大（比如50-200），否则可视化会一团糟，模拟速度也慢。先在小网络上调通逻辑。

4. SI模型实现与模拟分析

有了网络，我们就可以开始实现第一个模型了。SI模型的逻辑最直接，是理解传播模拟编程范式的最佳切入点。

4.1 算法步骤详解

SI模型的模拟过程可以分解为以下清晰步骤：

1. 初始化：
   • 给网络G中的每个节点添加一个属性state，初始值设为'S'（易感）。
   • 随机选择一定数量（比如1个或几个）的节点作为初始感染者，将其state属性改为'I'。
   • 初始化一个列表I_counts，用于记录每一步（时刻）的感染者数量。
2. 模拟循环：
   • 设定总模拟步数T。
   • 在每一步t： a. 遍历当前所有状态为'I'的节点。 b. 对于每个感染者节点i，遍历其所有邻居节点j。 c. 如果邻居j的状态是'S'，则生成一个[0,1)之间的随机数。如果这个随机数小于感染概率beta，则将节点j的状态改为'I'。 d.关键点：为了避免在同一时间步内，新感染的节点又去感染别人（这不符合离散时间步的假设），我们需要准备一个“待感染列表”。在本轮遍历中，只记录哪些S节点被选中，等所有感染者的传播尝试都检查完毕后，再统一更新这些节点的状态为'I'。 e. 记录当前步结束后的感染者总数，存入I_counts。
3. 终止与输出：
   • 循环结束后，返回I_counts列表。我们还可以可视化网络最终状态和感染人数曲线。

4.2 Python代码实现与注释

import numpy as np def simulate_si_model(G, beta=0.3, initial_infected=1, T=20): """ 在给定网络G上模拟SI传播模型。 参数: G: NetworkX图，代表社交网络。 beta: 感染概率，范围[0,1]。 initial_infected: 初始感染者数量。 T: 模拟的总时间步数。 返回: S_counts, I_counts: 列表，记录每一步的易感者和感染者数量。 G: 模拟结束后的网络，节点带有最终的state属性。 """ # 1. 初始化节点状态 nx.set_node_attributes(G, 'S', 'state') # 给所有节点添加初始状态'S' all_nodes = list(G.nodes()) # 随机选择初始感染者 infected_nodes = np.random.choice(all_nodes, size=initial_infected, replace=False) for node in infected_nodes: G.nodes[node]['state'] = 'I' # 初始化计数器列表 S_counts = [] I_counts = [] # 2. 开始模拟循环 for step in range(T): # 记录本轮待感染的节点 nodes_to_infect = [] # 获取当前所有感染者节点 current_infected = [n for n, attr in G.nodes(data=True) if attr['state'] == 'I'] # 遍历每个感染者 for inf_node in current_infected: # 遍历感染者的邻居 for neighbor in G.neighbors(inf_node): if G.nodes[neighbor]['state'] == 'S': # 以概率beta尝试感染 if np.random.rand() < beta: nodes_to_infect.append(neighbor) # 统一更新状态：将本轮被选中的易感者变为感染者 for node in nodes_to_infect: G.nodes[node]['state'] = 'I' # 统计当前状态人数 S_count = sum(1 for _, attr in G.nodes(data=True) if attr['state'] == 'S') I_count = sum(1 for _, attr in G.nodes(data=True) if attr['state'] == 'I') S_counts.append(S_count) I_counts.append(I_count) # 可选：如果感染者已经达到总人数，可以提前终止循环 if I_count == G.number_of_nodes(): print(f"在第{step+1}步，所有人均已感染。") # 补齐剩余步数的计数，保持列表长度一致 S_counts.extend([0] * (T - step - 1)) I_counts.extend([G.number_of_nodes()] * (T - step - 1)) break return S_counts, I_counts, G # 运行模拟 S_counts, I_counts, G_final = simulate_si_model(G, beta=0.2, initial_infected=2, T=15) # 可视化结果 plt.figure(figsize=(12, 4)) # 子图1：最终网络状态 plt.subplot(1, 2, 1) node_colors = ['red' if G_final.nodes[n]['state'] == 'I' else 'lightblue' for n in G_final] nx.draw(G_final, pos, node_color=node_colors, node_size=200, with_labels=False, edge_color='gray') plt.title(f"SI模型模拟最终状态 (Beta={0.2})") # 子图2：人数随时间变化曲线 plt.subplot(1, 2, 2) steps = list(range(len(I_counts))) plt.plot(steps, I_counts, 'r-', label='感染者 (I)', linewidth=2) plt.plot(steps, S_counts, 'b--', label='易感者 (S)', linewidth=2) plt.xlabel('时间步') plt.ylabel('人数') plt.title('SI模型传播动力学') plt.legend() plt.grid(True, alpha=0.3) plt.tight_layout() plt.show()

4.3 参数影响与结果分析

运行上面的代码，你会看到一张图。左图是模拟结束后网络的状态，红色节点是感染者，蓝色是易感者（在SI模型里，如果模拟时间足够长，最终应该全是红色）。右图是两条曲线，展示了S和I人数随时间的变化。

这里有几个关键点需要你动手尝试和观察：

1. 感染概率Beta： 这是最重要的参数。将beta从0.05调到0.5再运行。你会发现，beta很小时，红色曲线（I）上升得非常缓慢，可能直到模拟结束还有大量蓝色节点。beta很大时，红色曲线几乎垂直上升，迅速感染所有人。beta实际上决定了传播的“力度”。
2. 初始感染者位置与数量： 我们代码中是随机选的。你可以尝试修改代码，固定选择网络中度中心性最高的节点（最活跃的人）作为初始感染者，看看传播速度是否会加快。这引出了“影响力最大化”的雏形。
3. 网络结构的影响： 我们用的是WS小世界网络。你可以尝试用nx.erdos_renyi_graph(n, p)生成一个随机图（Erdos-Renyi模型），或者用nx.barabasi_albert_graph(n, m)生成一个无标度网络（Barabasi-Albert模型，存在少数高度节点）。在不同结构的网络上运行相同的SI模型，传播速度和最终范围会有显著差异。无标度网络中对高度节点的感染，会引发爆炸式的传播。

踩坑记录：在模拟循环中，最易犯的错误是“即时更新”。即在遍历感染者邻居时，一旦发现某个S节点满足感染条件，立刻将其状态改为I。这会导致这个在本轮刚被感染的节点，在同一轮中又以其新身份“I”去感染其他邻居，造成传播速度的严重高估。务必使用“待感染列表”进行缓冲更新。

5. SIR模型实现与深度探索

SIR模型引入了恢复机制，更贴近现实。它的实现比SI稍复杂一点，因为要管理三个状态和两个概率（β和γ）。

5.1 算法流程与状态管理

SIR模拟的步骤框架与SI类似，但状态转换逻辑变为：

1. 初始化：设置所有节点为S，随机选择初始I，R数量为0。为每个节点增加一个state属性。
2. 模拟循环（每一步）： a.感染过程：遍历所有I节点，对其每个S邻居以概率β尝试感染，将成功的邻居加入“新感染列表”。 b.恢复过程：遍历所有I节点（包括上一步刚产生的），每个节点以概率γ尝试恢复，将成功的节点加入“新恢复列表”。 c.状态更新：先统一将“新感染列表”中的节点状态从S改为I。再统一将“新恢复列表”中的节点状态从I改为R。

   这里有个重要顺序问题：必须先处理感染，再处理恢复，并且用列表缓冲。否则可能出现一个节点刚被感染，又在同一步被恢复的逻辑矛盾。 d. 记录S, I, R的数量。

3. 终止：可以设定最大步数，或者当I的数量降为0时提前终止。

5.2 代码实现与关键参数R0

def simulate_sir_model(G, beta=0.3, gamma=0.1, initial_infected=2, T=50): """ 在给定网络G上模拟SIR传播模型。 参数: G: NetworkX图。 beta: 感染概率。 gamma: 恢复概率。 initial_infected: 初始感染者数量。 T: 最大模拟步数。 返回: S_counts, I_counts, R_counts: 列表，记录每一步各状态人数。 G: 模拟结束后的网络。 """ # 初始化 nx.set_node_attributes(G, 'S', 'state') all_nodes = list(G.nodes()) infected_nodes = np.random.choice(all_nodes, size=initial_infected, replace=False) for node in infected_nodes: G.nodes[node]['state'] = 'I' S_counts, I_counts, R_counts = [], [], [] for step in range(T): new_infections = [] new_recoveries = [] # 获取当前所有感染者 current_infected = [n for n, attr in G.nodes(data=True) if attr['state'] == 'I'] # 感染阶段：I节点尝试感染S邻居 for inf_node in current_infected: for neighbor in G.neighbors(inf_node): if G.nodes[neighbor]['state'] == 'S': if np.random.rand() < beta: new_infections.append(neighbor) # 恢复阶段：I节点尝试恢复为R for inf_node in current_infected: if np.random.rand() < gamma: new_recoveries.append(inf_node) # 状态更新：先感染，后恢复 for node in new_infections: if G.nodes[node]['state'] == 'S': # 二次检查，防止状态冲突 G.nodes[node]['state'] = 'I' for node in new_recoveries: if G.nodes[node]['state'] == 'I': # 二次检查 G.nodes[node]['state'] = 'R' # 统计 S_count = sum(1 for _, attr in G.nodes(data=True) if attr['state'] == 'S') I_count = sum(1 for _, attr in G.nodes(data=True) if attr['state'] == 'I') R_count = sum(1 for _, attr in G.nodes(data=True) if attr['state'] == 'R') S_counts.append(S_count) I_counts.append(I_count) R_counts.append(R_count) # 如果感染者清零，提前结束 if I_count == 0: print(f"疫情在第{step+1}步结束。") break return S_counts, I_counts, R_counts, G # 运行模拟 S_counts, I_counts, R_counts, G_final_sir = simulate_sir_model(G.copy(), beta=0.2, gamma=0.05, initial_infected=3, T=80) # 可视化 plt.figure(figsize=(12, 5)) steps = list(range(len(S_counts))) plt.plot(steps, S_counts, 'b-', label='易感者 (S)', linewidth=2) plt.plot(steps, I_counts, 'r-', label='感染者 (I)', linewidth=2) plt.plot(steps, R_counts, 'g-', label='移除者 (R)', linewidth=2) plt.xlabel('时间步') plt.ylabel('人数') plt.title('SIR模型传播动力学 (Beta=0.2, Gamma=0.05)') plt.legend() plt.grid(True, alpha=0.3) plt.show()

5.3 模拟实验与现象观察

运行代码后，你会看到经典的SIR曲线：S（蓝色）从高位逐渐下降；I（红色）先上升达到一个峰值，然后下降至0；R（绿色）从0开始，最终累积到一个稳定值。

现在，我们来做个关键的实验，理解基本再生数 R0的概念。在均匀混合的假设下，R0 = β / γ。它代表一个感染者在整个感染期内，平均能传染多少个易感者。

• 当 R0 > 1：每个感染者平均能传染超过1个人，疫情会扩散（I曲线会先上升）。
• 当 R0 < 1：每个感染者平均传染不到1个人，疫情会逐渐消失（I曲线单调下降）。

我们可以通过调整β和γ来验证：

1. 设置 R0 > 1：例如beta=0.3, gamma=0.1， R0=3。运行模拟，你会看到明显的疫情爆发波形。
2. 设置 R0 < 1：例如beta=0.05, gamma=0.1， R0=0.5。运行模拟，你会发现I人数从开始就缓慢下降，无法形成大规模传播。

实操心得：在网络模型中，R0的计算比均匀混合模型复杂，因为它还依赖于网络的平均度（连接数）等拓扑性质。一个近似的经验公式是 R0_network ≈ β / γ * ，其中 是网络的平均度。在我们的WS网络（n=50, k=4）中，平均度约为4。当β/γ * 4 > 1时，疫情更容易在网络中持续传播。你可以用这个经验去设计你的参数，观察现象。

6. IC模型实现与影响力分析

独立级联模型（IC）的模拟逻辑与前两者有显著区别，它更关注离散的“尝试”和“级联”过程。

6.1 离散级联过程实现

IC模型的核心是“轮次”和“仅新激活节点有传播机会”。我们需要记录每个节点是在哪一轮被激活的。

def simulate_ic_model(G, p=0.2, seeds=None, max_iter=20): """ 在给定网络G上模拟独立级联模型。 参数: G: NetworkX图。 p: 独立激活概率。 seeds: 初始激活节点列表。如果为None，则随机选一个。 max_iter: 最大模拟轮次。 返回: active_nodes_by_round: 列表的列表，记录每一轮新激活的节点。 total_active: 列表，记录每一轮累计激活节点数。 G: 模拟结束后的网络，节点带有‘active_round’属性（-1表示未激活，>=0表示激活轮次）。 """ # 初始化：所有节点未激活，轮次标记为-1 nx.set_node_attributes(G, -1, 'active_round') if seeds is None: seeds = [np.random.choice(list(G.nodes()))] # 第0轮：激活种子节点 round = 0 newly_active = seeds for node in newly_active: G.nodes[node]['active_round'] = round # 记录每一轮新激活的节点和累计激活数 active_nodes_by_round = [newly_active.copy()] total_active = [len(newly_active)] # 开始级联 while round < max_iter and newly_active: round += 1 current_newly_active = [] # 遍历上一轮新激活的节点 for node in newly_active: # 遍历其未激活的邻居 for neighbor in G.neighbors(node): if G.nodes[neighbor]['active_round'] == -1: # 未激活 # 以概率p尝试激活，每个邻居只有一次被该节点尝试的机会 if np.random.rand() < p: current_newly_active.append(neighbor) # 去重：一个节点可能被多个邻居在同一轮尝试激活 current_newly_active = list(set(current_newly_active)) # 激活本轮成功的节点 for node in current_newly_active: G.nodes[node]['active_round'] = round active_nodes_by_round.append(current_newly_active) total_active.append(total_active[-1] + len(current_newly_active)) # 更新newly_active为当前轮新激活的节点，用于下一轮 newly_active = current_newly_active # 如果提前结束，补全记录 while len(total_active) <= max_iter: active_nodes_by_round.append([]) total_active.append(total_active[-1]) return active_nodes_by_round, total_active, G # 运行模拟 seeds = [0, 5] # 选择节点0和5作为种子 active_rounds, total_active, G_final_ic = simulate_ic_model(G.copy(), p=0.15, seeds=seeds, max_iter=10) # 可视化激活过程 plt.figure(figsize=(10, 4)) # 绘制累计激活曲线 plt.subplot(1, 2, 1) rounds = list(range(len(total_active))) plt.plot(rounds, total_active, 'bo-', linewidth=2, markersize=6) plt.xlabel('传播轮次') plt.ylabel('累计激活节点数') plt.title('IC模型累计激活曲线 (p=0.15)') plt.grid(True, alpha=0.3) # 绘制最终网络状态（按激活轮次着色） plt.subplot(1, 2, 2) # 为不同轮次分配颜色 cmap = plt.cm.viridis node_colors = [] for n in G_final_ic.nodes(): r = G_final_ic.nodes[n]['active_round'] if r == -1: node_colors.append('lightgray') # 未激活 else: # 激活轮次越早，颜色越深（这里用轮次归一化） node_colors.append(cmap(r / max(1, max(active_rounds)))) nx.draw(G_final_ic, pos, node_color=node_colors, node_size=200, with_labels=False, edge_color='gray') plt.title('IC模型激活状态（颜色深浅代表激活轮次）') plt.tight_layout() plt.show()

6.2 种子节点选择策略初探

IC模型常用来研究“影响力最大化”：给定一个预算k（只能选k个种子节点），如何选择能使最终激活的节点总数最多？这是一个NP难问题，但有高效的启发式算法。最著名的是贪心算法，其核心思想是迭代地选择能带来最大边际收益的节点。

我们可以实现一个简单的模拟贪心算法来感受一下：

1. 初始化一个空种子集S。
2. 对于每一个不在S中的节点v，计算如果将v加入S，运行多次IC模拟后的平均激活节点数（即边际增益）。
3. 选择边际增益最大的节点加入S。
4. 重复步骤2-3，直到S包含k个节点。

由于每次模拟都有随机性，我们需要对每个候选节点进行多次模拟（比如100次）取平均，以获得稳定的收益估计。这个算法计算量很大（O(knR*模拟时间)），但对于理解思想足够了。在实际研究中，会使用更高效的算法如CELF（Cost-Effective Lazy Forward）来优化。

def greedy_influence_maximization(G, k=3, p=0.1, iterations=100): """ 一个简单（低效）的贪心算法用于影响力最大化。 注意：此函数仅用于演示原理，在大网络上效率极低。 """ seeds = [] all_nodes = set(G.nodes()) for i in range(k): print(f"选择第 {i+1} 个种子...") best_node = None best_influence = -1 # 遍历所有尚未被选为种子的节点 candidates = all_nodes - set(seeds) for node in candidates: # 计算当前种子集 + 候选节点 的影响力 current_seeds = seeds + [node] total_spread = 0 # 多次模拟取平均 for _ in range(iterations): _, total_active, _ = simulate_ic_model(G.copy(), p=p, seeds=current_seeds, max_iter=20) total_spread += total_active[-1] # 取最终激活数 avg_spread = total_spread / iterations # 计算边际增益（可选，这里直接用总影响力） if avg_spread > best_influence: best_influence = avg_spread best_node = node if best_node is not None: seeds.append(best_node) print(f" 选中节点 {best_node}, 预估影响力 {best_influence:.1f}") return seeds # 注意：在小网络上运行，因为计算量很大 small_G = create_social_network(n=30, k=4, p=0.1) selected_seeds = greedy_influence_maximization(small_G, k=3, p=0.15, iterations=50) print(f"贪心算法选出的种子节点: {selected_seeds}")

运行这个代码可能需要一点时间。它会输出算法依次选择的种子节点。你可以对比一下，随机选择3个节点作为种子，和用这个贪心算法选出的3个节点，分别运行IC模型，最终的激活规模是否有显著差异。通常，贪心算法会选择那些处于网络中心位置（比如度中心性高、介数中心性高）的节点。

7. 模型对比、应用场景与常见问题

7.1 三大模型核心对比

为了更清晰地理解这三个模型的区别和适用场景，我整理了一个对比表格：

7.2 模型选择与场景适配

在实际项目中，选择哪个模型取决于你要分析的具体问题：

• 如果你想研究一个长期存在的观念或技术的普及过程，并且假设人们一旦接受就不会“反悔”，那么SI模型是一个简化的起点。
• 如果你想分析一次疫情爆发、一个短期热点话题（如爆款短视频）的传播生命周期，SIR模型是最佳选择。你可以通过拟合真实数据（如每日新增话题量）来反推β和γ参数。
• 如果你的目标是做营销策划，比如寻找最合适的“KOC”进行产品投放以最大化曝光，那么IC模型及其相关的影响力最大化算法就是你的核心工具。你需要收集或构建用户间的社交关系图（关注、好友关系）。

7.3 常见问题与调试技巧

在实现和运行这些模型时，你可能会遇到以下典型问题：

1. 传播速度过快或过慢，不符合预期

   • 检查概率参数：β、γ、p的值通常很小。在真实社交网络中，单次接触的传播概率很少超过0.1。可以从0.01、0.05这样的小值开始尝试。
   • 检查网络密度：用nx.density(G)查看你的网络密度。一个完全图（所有节点两两相连）的传播速度会极快。WS小世界网络的密度约为k/(n-1)，相对稀疏。
   • 检查初始感染者位置：随机选择可能选到边缘节点。尝试固定选择网络中度数最高的节点作为初始感染者，观察传播速度的变化。

2. 模拟结果波动很大，每次运行都不一样

   • 这是正常的：因为感染/激活是概率事件。为了得到稳定结论，必须进行多次模拟取平均。例如，对同一组参数和初始条件，运行100次模拟，然后绘制平均曲线和置信区间。

   def run_multiple_simulations(model_func, G, params, times=100): results = [] for _ in range(times): # 注意：每次模拟要使用网络的副本，避免状态污染 G_copy = G.copy() result = model_func(G_copy, **params) results.append(result) return results # 然后对results列表中的数据（如最终的感染人数）进行统计分析

3. 代码运行太慢（特别是对于大网络或IC的贪心算法）

   • 向量化操作：在SI/SIR模型中，遍历所有感染者的邻居是主要开销。对于大型网络，可以考虑使用邻接矩阵，利用NumPy的矩阵运算进行概率判断，但这会消耗更多内存。
   • 减少模拟次数：在调试阶段，减少网络规模(n)、模拟步数(T)和重复次数(iterations)。
   • 使用更高效的算法库：对于真正的研究，可以考虑使用专门优化过的库，如NDlib（Network Diffusion Library）。

4. 如何将模型应用到真实数据？

   • 数据获取：真实的社交网络数据可能来自API（如Twitter, Weibo的粉丝关系）、合作方脱敏数据、或公开数据集（如Stanford Large Network Dataset Collection）。
   • 网络构建：将用户视为节点，关注/好友关系视为边，构建有向或无向图。
   • 参数估计：这是最难也是最关键的一步。可以通过历史数据（如过去话题的传播轨迹）来拟合模型参数（如β, γ）。常用方法有极大似然估计（MLE）或基于模拟的方法（如Approximate Bayesian Computation）。
   • 模型验证：用一部分数据（训练集）估计参数，在另一部分数据（测试集）上预测传播范围，比较预测值与真实值的差异。

实现这三个模型只是第一步，它们像积木一样，可以组合、扩展成更复杂的模型，如SIS（感染后可再次易感）、SEIR（增加潜伏期）、LT模型（线性阈值模型）等。理解这些基础模型的每一个细节，能让你在面对更复杂的传播现象时，拥有拆解和建模的能力。