复杂网络应用案例分析

# 使用NetworkX构建PPI网络模型
import networkx as nx
import pandas as pd

# 从实验数据加载相互作用
# 数据格式: protein1, protein2, confidence_score
ppi_data = pd.read_csv("ppi_data.csv")

# 构建无向图
ppi_network = nx.Graph()

# 添加节点和边
for _, row in ppi_data.iterrows():
    protein1 = row['protein1']
    protein2 = row['protein2']
    confidence = row['confidence_score']
    
    # 添加节点（确保所有蛋白质都被包含）
    ppi_network.add_node(protein1)
    ppi_network.add_node(protein2)
    
    # 添加带置信度属性的边
    ppi_network.add_edge(protein1, protein2, confidence=confidence)

# 输出网络基本信息
print(f"蛋白质数量: {ppi_network.number_of_nodes()}")
print(f"相互作用数量: {ppi_network.number_of_edges()}")

# 过滤低置信度的相互作用
high_conf_edges = [(u, v) for u, v, d in ppi_network.edges(data=True) 
                  if d['confidence'] > 0.7]
filtered_ppi = ppi_network.edge_subgraph(high_conf_edges)
print(f"过滤后相互作用数量: {filtered_ppi.number_of_edges()}")

# PPI网络基础指标分析
import networkx as nx
import matplotlib.pyplot as plt
import numpy as np

# 假设ppi_network是已构建的PPI网络

# 1. 度分布分析
degrees = [d for n, d in ppi_network.degree()]
degree_distribution = nx.degree_histogram(ppi_network)

plt.figure(figsize=(12, 5))

# 绘制度分布
plt.subplot(1, 2, 1)
plt.plot(degree_distribution, 'b-', marker='o')
plt.title('PPI网络度分布')
plt.xlabel('度')
plt.ylabel('频数')

# 绘制双对数坐标下的度分布（判断是否符合幂律）
plt.subplot(1, 2, 2)
plt.loglog(degree_distribution, 'b-', marker='o')
plt.title('双对数坐标下的度分布')
plt.xlabel('log(度)')
plt.ylabel('log(频数)')

plt.tight_layout()
plt.show()

# 2. 聚类系数分析
avg_clustering = nx.average_clustering(ppi_network)
print(f"平均聚类系数: {avg_clustering:.4f}")

# 3. 路径长度分析
if nx.is_connected(ppi_network):
    avg_path_length = nx.average_shortest_path_length(ppi_network)
    print(f"平均路径长度: {avg_path_length:.4f}")
    diameter = nx.diameter(ppi_network)
    print(f"网络直径: {diameter}")

# 4. 中心性分析
degree_centrality = nx.degree_centrality(ppi_network)
betweenness_centrality = nx.betweenness_centrality(ppi_network)

# 排序并获取 top 10 关键蛋白质
top_degree = sorted(degree_centrality.items(), key=lambda x: x[1], reverse=True)[:10]
top_betweenness = sorted(betweenness_centrality.items(), key=lambda x: x[1], reverse=True)[:10]

print("基于度中心性的关键蛋白质:", [node for node, _ in top_degree])
print("基于介数中心性的关键蛋白质:", [node for node, _ in top_betweenness])

# 基于谱聚类的蛋白质功能模块识别
import networkx as nx
import numpy as np
from sklearn.cluster import KMeans

def identify_functional_modules(ppi_network, num_modules):
    # 计算拉普拉斯矩阵
    laplacian = nx.normalized_laplacian_matrix(ppi_network).toarray()
    
    # 求解特征值和特征向量
    eigenvalues, eigenvectors = np.linalg.eigh(laplacian)
    
    # 选择对应于最小非零特征值的特征向量
    # 跳过第一个特征值（对应于0）
    selected_eigenvectors = eigenvectors[:, 1:num_modules+1]
    
    # 应用K-means聚类
    kmeans = KMeans(n_clusters=num_modules, random_state=42)
    clusters = kmeans.fit_predict(selected_eigenvectors)
    
    # 将聚类结果组织为功能模块
    modules = {}
    for i, node in enumerate(ppi_network.nodes()):
        cluster_id = clusters[i]
        if cluster_id not in modules:
            modules[cluster_id] = []
        modules[cluster_id].append(node)
    
    return modules

# 应用算法
functional_modules = identify_functional_modules(ppi_network, num_modules=8)

# 输出结果
for module_id, proteins in functional_modules.items():
    print(f"功能模块 {module_id} 包含 {len(proteins)} 个蛋白质")

# 构建社交推荐异构网络
import networkx as nx
import pandas as pd

# 创建一个有向图来表示异构网络
social_rec_graph = nx.DiGraph()

# 加载数据
user_item_interactions = pd.read_csv("user_item.csv")  # 用户-物品交互
social_relations = pd.read_csv("social_relations.csv")  # 用户社交关系
item_features = pd.read_csv("item_features.csv")        # 物品特征

# 添加用户节点和物品节点
users = set(user_item_interactions['user_id'].unique())
items = set(user_item_interactions['item_id'].unique())

social_rec_graph.add_nodes_from(users, type='user')
social_rec_graph.add_nodes_from(items, type='item')

# 添加用户-物品交互边（带评分属性）
for _, row in user_item_interactions.iterrows():
    user = row['user_id']
    item = row['item_id']
    rating = row['rating']
    social_rec_graph.add_edge(user, item, type='interaction', weight=rating)

# 添加用户-用户社交边（带信任度属性）
for _, row in social_relations.iterrows():
    user1 = row['user1']
    user2 = row['user2']
    trust = row['trust_score']
    social_rec_graph.add_edge(user1, user2, type='social', weight=trust)

# 添加物品属性
for _, row in item_features.iterrows():
    item = row['item_id']
    features = {k: v for k, v in row.items() if k != 'item_id'}
    for k, v in features.items():
        social_rec_graph.nodes[item][k] = v

# 网络基本信息
print(f"用户数量: {len(users)}")
print(f"物品数量: {len(items)}")
print(f"用户-物品交互数量: {len(user_item_interactions)}")
print(f"社交关系数量: {len(social_relations)}")

# 社交推荐网络基础指标分析
import networkx as nx
import matplotlib.pyplot as plt
import numpy as np

# 假设social_rec_graph是已构建的异构网络

# 1. 提取用户子网络和用户-物品二部图
user_nodes = [n for n, attr in social_rec_graph.nodes(data=True) if attr['type'] == 'user']
item_nodes = [n for n, attr in social_rec_graph.nodes(data=True) if attr['type'] == 'item']

# 用户社交子网络
social_subgraph = social_rec_graph.subgraph(user_nodes)
# 只保留社交边
social_edges = [(u, v) for u, v, d in social_subgraph.edges(data=True) if d['type'] == 'social']
social_network = social_subgraph.edge_subgraph(social_edges)

# 用户-物品二部图
ui_edges = [(u, v) for u, v, d in social_rec_graph.edges(data=True) if d['type'] == 'interaction']
ui_bipartite = nx.Graph()
ui_bipartite.add_edges_from(ui_edges)

# 2. 度分布分析（用户社交网络）
out_degrees = [d for n, d in social_network.out_degree()]
in_degrees = [d for n, d in social_network.in_degree()]

plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.hist(out_degrees, bins=30, alpha=0.7, label='出度（关注）')
plt.hist(in_degrees, bins=30, alpha=0.7, label='入度（被关注）')
plt.title('用户社交网络度分布')
plt.xlabel('度')
plt.ylabel('频数')
plt.legend()

# 3. 用户活跃度分析（与物品交互数量）
user_activity = [social_rec_graph.out_degree(u, weight='weight') for u in user_nodes]

plt.subplot(1, 2, 2)
plt.hist(user_activity, bins=30, log=True)
plt.title('用户活跃度分布（对数坐标）')
plt.xlabel('交互权重总和')
plt.ylabel('频数（log）')

plt.tight_layout()
plt.show()

# 4. 同配性分析
assortativity = nx.degree_assortativity_coefficient(social_network)
print(f"社交网络同配系数: {assortativity:.4f}")

# 5. 二部图分析
ui_density = nx.density(ui_bipartite)
print(f"用户-物品二部图密度: {ui_density:.6f}")

# 计算用户平均物品数和物品平均用户数
avg_items_per_user = np.mean([ui_bipartite.degree(u) for u in user_nodes])
avg_users_per_item = np.mean([ui_bipartite.degree(i) for i in item_nodes])
print(f"平均每个用户交互的物品数: {avg_items_per_user:.2f}")
print(f"平均每个物品被交互的用户数: {avg_users_per_item:.2f}")

# 社交正则化矩阵分解推荐算法
import numpy as np
from sklearn.metrics import mean_squared_error

class SocialRegularizedMF:
    def __init__(self, n_factors=20, lambda_u=0.01, lambda_v=0.01, 
                 lambda_s=0.1, iterations=100):
        self.n_factors = n_factors    # 特征维度
        self.lambda_u = lambda_u      # 用户正则化参数
        self.lambda_v = lambda_v      # 物品正则化参数
        self.lambda_s = lambda_s      # 社交正则化参数
        self.iterations = iterations  # 迭代次数
    
    def fit(self, R, S):
        """
        R: 用户-物品评分矩阵 (m x n)
        S: 社交关系矩阵 (m x m)
        """
        self.m, self.n = R.shape  # m个用户, n个物品
        self.R = R
        self.S = S
        
        # 初始化用户和物品特征矩阵
        self.U = np.random.normal(scale=1./self.n_factors, 
                                 size=(self.m, self.n_factors))
        self.V = np.random.normal(scale=1./self.n_factors, 
                                 size=(self.n, self.n_factors))
        
        # 梯度下降迭代
        for i in range(self.iterations):
            # 更新用户特征
            for u in range(self.m):
                # 找到用户u评价过的物品
                I_u = np.where(R[u, :] > 0)[0]
                if len(I_u) == 0:
                    continue
                
                # 计算梯度并更新
                V_Iu = self.V[I_u, :]
                R_Iu = self.R[u, I_u]
                term1 = np.dot(V_Iu.T, V_Iu) + self.lambda_u * np.eye(self.n_factors)
                term2 = np.dot(V_Iu.T, R_Iu) + self.lambda_s * np.dot(S[u, :], self.U)
                self.U[u, :] = np.linalg.solve(term1, term2)
            
            # 更新物品特征
            for v in range(self.n):
                # 找到评价过物品v的用户
                U_v = np.where(R[:, v] > 0)[0]
                if len(U_v) == 0:
                    continue
                
                # 计算梯度并更新
                U_Uv = self.U[U_v, :]
                R_Uv = self.R[U_v, v]
                term1 = np.dot(U_Uv.T, U_Uv) + self.lambda_v * np.eye(self.n_factors)
                term2 = np.dot(U_Uv.T, R_Uv)
                self.V[v, :] = np.linalg.solve(term1, term2)
            
            # 计算并打印当前误差
            if (i + 1) % 10 == 0:
                pred = self.predict()
                error = mean_squared_error(R[R > 0], pred[R > 0])
                print(f"Iteration {i+1}, MSE: {error:.4f}")
    
    def predict(self, u=None, v=None):
        """预测评分"""
        if u is not None and v is not None:
            return np.dot(self.U[u, :], self.V[v, :].T)
        elif u is not None:
            return np.dot(self.U[u, :], self.V.T)
        else:
            return np.dot(self.U, self.V.T)

# 使用示例
# 假设R是用户-物品评分矩阵，S是社交关系矩阵
# model = SocialRegularizedMF(n_factors=20, iterations=50)
# model.fit(R, S)
# 为用户u推荐物品
# user_id = 0
# predictions = model.predict(u=user_id)
# top_items = np.argsort(predictions)[::-1][:10]  # 推荐top 10物品
# print(f"为用户{user_id}推荐的物品: {top_items}")