运用si感染模型感染导入的'football.edge'数据集，输出打印节点感染状态和邻居，之后设置观测节点，利用定位源的反向传播初始时间的方差来定位，输出结果并可视化

好的，需要先安装 `networkx` 和 `numpy` 两个 Python 模块，可以使用以下命令进行安装：

pip install networkx numpy

接下来就可以开始编写代码了。首先读入数据集，构建图：

import networkx as nx

# 读入数据集
G = nx.read_edgelist('football.edge')

# 设置初始感染节点
infected_nodes = ['NotreDame', 'BrighamYoung']

# 设置感染率和恢复率
infection_rate = 0.2
recovery_rate = 0.1

# 初始化节点状态和传播时间
node_status = {}
node_time = {}
for node in G.nodes():
    if node in infected_nodes:
        node_status[node] = 1
        node_time[node] = 0
    else:
        node_status[node] = 0
        node_time[node] = float('inf')

接下来可以使用 SI 模型进行传播：

import numpy as np

# 进行感染传播
def infect_neighbors(node):
    for neighbor in G.neighbors(node):
        if node_status[neighbor] == 0 and np.random.random() < infection_rate:
            node_status[neighbor] = 1

# 进行恢复传播
def recover_nodes():
    for node in G.nodes():
        if node_status[node] == 1 and np.random.random() < recovery_rate:
            node_status[node] = 0

# 进行感染传播和恢复传播，直到没有新感染节点为止
while True:
    new_infected_nodes = []
    for node in G.nodes():
        if node_status[node] == 1:
            new_infected_nodes.append(node)
            infect_neighbors(node)
    recover_nodes()
    if len(new_infected_nodes) == 0:
        break
    else:
        for node in new_infected_nodes:
            node_time[node] = min(node_time[node], len(new_infected_nodes))

接下来可以输出节点感染状态和邻居：

# 输出节点感染状态和邻居
for node in G.nodes():
    print(f'{node}: {node_status[node]}')
    print(f'Neighbors: {list(G.neighbors(node))}')

最后，可以设置观测节点，利用定位源的反向传播初始时间的方差来定位，并对结果进行可视化：

import matplotlib.pyplot as plt

# 设置观测节点
observed_nodes = ['NotreDame', 'Michigan']

# 定义反向传播函数
def reverse_time(node, time, variance):
    if node in observed_nodes:
        return (time - variance, time + variance)
    else:
        neighbors = list(G.neighbors(node))
        infected_neighbors = [n for n in neighbors if node_status[n] == 1]
        if len(infected_neighbors) == 0:
            return (float('inf'), float('inf'))
        else:
            avg_time = sum([node_time[n] for n in infected_neighbors]) / len(infected_neighbors)
            return (avg_time - variance, avg_time + variance)

# 定义定位函数
def locate_source(variance):
    min_time = float('inf')
    min_node = None
    for node in G.nodes():
        time_range = reverse_time(node, node_time[node], variance)
        if time_range[0] < min_time:
            min_time = time_range[0]
            min_node = node
    return min_node

# 进行定位
source_node = locate_source(1)

# 可视化
pos = nx.spring_layout(G)
nx.draw(G, pos, node_color=[node_status[node] for node in G.nodes()], cmap='coolwarm', alpha=0.8)
nx.draw_networkx_nodes(G, pos, nodelist=[source_node], node_color='red', node_size=1000)
plt.show()

运行以上代码，就可以得到输出节点感染状态和邻居的结果和可视化结果。定位源的结果可以通过 `source_node` 获得。