如何利用scipy.sparse稀疏矩阵实现结构化dtype？

我完全懂你现在的困扰——想用稀疏结构处理带多属性权重的有向图，但Scipy的dok/coo格式不仅没法像结构化数组那样按字段（比如'a'）直接切片，运算效率还不高。下面给你几个实用的解决方案，都是基于Scipy生态或者常用工具的：

方案1：用多个独立的CSR稀疏矩阵存储各权重字段 #

这是最直接高效的方法，因为Scipy的csr_matrix是运算性能最优的稀疏格式，支持矩阵乘法、求和、切片等几乎所有数值操作。我们可以给每个权重字段单独建一个CSR矩阵，再用字典封装起来方便按字段访问。

import scipy.sparse as sp
import numpy as np

# 假设你的边数据是(src, dst, a_weight, b_weight)的列表
edges = [(0, 1, 0.5, 2.3), (1, 2, 1.1, 4.5), (0, 2, 0.8, 3.1)]

# 拆分边数据的各个部分
src_nodes = [e[0] for e in edges]
dst_nodes = [e[1] for e in edges]
a_weights = [e[2] for e in edges]
b_weights = [e[3] for e in edges]

# 计算图的节点总数
total_nodes = max(max(src_nodes), max(dst_nodes)) + 1

# 为每个权重字段创建CSR矩阵
a_matrix = sp.csr_matrix((a_weights, (src_nodes, dst_nodes)), shape=(total_nodes, total_nodes))
b_matrix = sp.csr_matrix((b_weights, (src_nodes, dst_nodes)), shape=(total_nodes, total_nodes))

# 用字典封装，实现按键访问
weight_matrices = {"a": a_matrix, "b": b_matrix}

# 示例操作：按字段访问并运算
print(weight_matrices["a"][0, 1])  # 获取(0,1)边的a权重
result = weight_matrices["b"].dot(np.array([1, 0, 1]))  # 对b权重矩阵做向量乘法

优点：完全利用Scipy稀疏矩阵的高性能，实现简单，无额外依赖；缺点：权重字段较多时，字典的管理会稍显繁琐，但胜在直观可控。

方案2：自定义结构化稀疏图类 #

如果希望把多字段权重封装成一个统一的对象，方便管理和访问，可以自己写一个简单的类，内部用结构化数组存储权重数据，同时缓存每个字段的CSR矩阵来保证运算效率。

import numpy as np
import scipy.sparse as sp

class StructuredSparseGraph:
    def __init__(self, edges, weight_fields):
        # 提取边的源节点、目标节点
        self.rows = np.array([e[0] for e in edges])
        self.cols = np.array([e[1] for e in edges])
        # 用numpy结构化数组存储多权重数据
        dtype = [(field, float) for field in weight_fields]
        self.weight_data = np.array([tuple(e[2:]) for e in edges], dtype=dtype)
        self.fields = weight_fields
        self.total_nodes = max(max(self.rows), max(self.cols)) + 1
        # 缓存各字段的CSR矩阵，避免重复构建
        self._csr_cache = {}

    def __getitem__(self, field):
        """实现按键（字段名）访问对应的稀疏矩阵"""
        if field not in self._csr_cache:
            # 从结构化数组中提取对应字段的数据，构建CSR矩阵
            field_weights = self.weight_data[field]
            self._csr_cache[field] = sp.csr_matrix(
                (field_weights, (self.rows, self.cols)),
                shape=(self.total_nodes, self.total_nodes)
            )
        return self._csr_cache[field]

# 使用示例
edges = [(0,1,0.5,2.3), (1,2,1.1,4.5), (0,2,0.8,3.1)]
graph = StructuredSparseGraph(edges, weight_fields=["a", "b"])

# 按字段访问稀疏矩阵并操作
a_matrix = graph["a"]
print(a_matrix.sum(axis=1))  # 对a权重按行求和
print(graph["b"][1, 2])  # 获取(1,2)边的b权重

优点：封装性好，访问方式更贴近结构化数据的习惯，内部缓存保证了运算效率；缺点：需要自己维护类的逻辑，适合字段较多、需要统一管理的场景。

方案3：结合NetworkX处理图结构+稀疏矩阵 #

如果你的场景不仅需要数值运算，还涉及图结构操作（比如路径查找、拓扑排序、节点度计算等），可以用NetworkX存储带属性的边，再导出为Scipy稀疏矩阵做数值运算。

import networkx as nx
import scipy.sparse as sp

# 创建有向图并添加带属性的边
directed_graph = nx.DiGraph()
directed_graph.add_edge(0, 1, a=0.5, b=2.3)
directed_graph.add_edge(1, 2, a=1.1, b=4.5)
directed_graph.add_edge(0, 2, a=0.8, b=3.1)

# 导出各权重字段的CSR矩阵
a_matrix = nx.to_scipy_sparse_array(directed_graph, weight="a", format="csr")
b_matrix = nx.to_scipy_sparse_array(directed_graph, weight="b", format="csr")

# 同样可以封装成字典方便访问
weight_matrices = {"a": a_matrix, "b": b_matrix}

优点：同时支持图结构操作和高效数值运算，适合复杂的图分析场景；缺点：引入了NetworkX依赖，如果只需要数值运算的话有点冗余。

内容的提问来源于stack exchange，提问作者Josh.F