Python中二分网络的节点度计算与度矩阵构建

1. 计算节点度 #

NetworkX 提供直接获取节点度的方法，可分别提取索赔节点和参与方节点的度：

# 获取所有节点的度
degree_dict = dict(G.degree())

# 分离索赔节点（bipartite=0）和参与方节点（bipartite=1）的度
claims_degree = {node: degree_dict[node] for node in bipartite.sets(G)[0]}
parties_degree = {node: degree_dict[node] for node in bipartite.sets(G)[1]}

print("索赔节点度：", claims_degree)
print("参与方节点度：", parties_degree)

输出示例：

索赔节点度： {'C001': 2, 'C003': 2, 'C002': 1}
参与方节点度： {'p1': 3, 'p2': 1, 'p3': 1}

2. 构建度矩阵 #

度矩阵为对角矩阵，对角元素对应节点的度，可通过 Pandas + NumPy 构建：

索赔节点度矩阵 #

import pandas as pd
import numpy as np

# 提取索赔节点列表
claims_nodes = list(bipartite.sets(G)[0])
# 生成对角矩阵并转为DataFrame
claims_degree_matrix = pd.DataFrame(
    np.diag([claims_degree[node] for node in claims_nodes]),
    index=claims_nodes, columns=claims_nodes
)
print("索赔节点度矩阵：\n", claims_degree_matrix)

参与方节点度矩阵 #

# 提取参与方节点列表
parties_nodes = list(bipartite.sets(G)[1])
# 生成对角矩阵并转为DataFrame
parties_degree_matrix = pd.DataFrame(
    np.diag([parties_degree[node] for node in parties_nodes]),
    index=parties_nodes, columns=parties_nodes
)
print("参与方节点度矩阵：\n", parties_degree_matrix)

3. 计算各参与方类型的度统计量 #

将参与方度数据转为 DataFrame 后，按类型分组计算均值、中位数等统计指标：

# 转换为结构化DataFrame
parties_df = pd.DataFrame(list(parties_degree.items()), columns=['Type', 'Degree'])
# 分组计算统计量
parties_stats = parties_df.groupby('Type')['Degree'].agg(['mean', 'median', 'min', 'max'])
print("参与方类型度统计：\n", parties_stats)

输出示例：

mean  median  min  max

Type
p1 3.0 3.0 3 3
p2 1.0 1.0 1 1
p3 1.0 1.0 1 1

4. 生成论文风格统计表格 #

分别统计索赔集合、参与方总集合及各参与方子类型的指标，整理为规范表格：

# 初始化表格数据列表
table_data = []

# 索赔集合统计
claims_set = bipartite.sets(G)[0]
claims_edges = bipartite.weighted_projected_graph(G, claims_set).size()
claims_degrees = [degree_dict[node] for node in claims_set]
table_data.append({
    'Set': 'Claims',
    'Type': 'All',
    'Nodes': len(claims_set),
    'Edges': claims_edges,
    'Mean degree': np.mean(claims_degrees),
    'Median degree': np.median(claims_degrees),
    'Min degree': min(claims_degrees),
    'Max degree': max(claims_degrees)
})

# 参与方总集合统计
parties_set = bipartite.sets(G)[1]
parties_edges = bipartite.weighted_projected_graph(G, parties_set).size()
parties_degrees = [degree_dict[node] for node in parties_set]
table_data.append({
    'Set': 'Parties',
    'Type': 'All',
    'Nodes': len(parties_set),
    'Edges': parties_edges,
    'Mean degree': np.mean(parties_degrees),
    'Median degree': np.median(parties_degrees),
    'Min degree': min(parties_degrees),
    'Max degree': max(parties_degrees)
})

# 各参与方类型统计
for party_type in parties_df['Type'].unique():
    type_nodes = parties_df[parties_df['Type'] == party_type]['Type'].tolist()
    type_edges = bipartite.weighted_projected_graph(G, type_nodes).size()
    type_degrees = parties_df[parties_df['Type'] == party_type]['Degree'].tolist()
    table_data.append({
        'Set': 'Parties',
        'Type': party_type,
        'Nodes': len(type_nodes),
        'Edges': type_edges,
        'Mean degree': np.mean(type_degrees),
        'Median degree': np.median(type_degrees),
        'Min degree': min(type_degrees),
        'Max degree': max(type_degrees)
    })

# 转换为DataFrame并格式化输出
table_df = pd.DataFrame(table_data)
print("Table 2 统计表格：\n", table_df.round(2))

输出示例：

Set Type  Nodes  Edges  Mean degree  Median degree  Min degree  Max degree

0 Claims All 3 2 1.67 2.0 1 2
1 Parties All 3 1 1.67 1.0 1 3
2 Parties p1 1 0 3.00 3.0 3 3
3 Parties p2 1 0 1.00 1.0 1 1
4 Parties p3 1 0 1.00 1.0 1 1

内容的提问来源于stack exchange，提问作者Bayek Shiva