【笔记 Pytorch】稀疏矩阵、scipy.sparse模块的使用

安装：pip install scipy
描述：就是专门为了解决稀疏矩阵而生。导入模块：from scipy import sparse

优缺点总结

七种矩阵类型	描述
coo_matrix ★	【名称】coordinate format 【优点】    ① 不同稀疏格式间转换效率高(特别是CSR和CSC)    ② 不支持元素的存取和增删，但是易于保存和读取。    ③ 构建矩阵时，允许坐标重复。 【缺点】    ① 不能直接运算；    ② 不能直接切片操作。
dok_matrix	【说明】基于Keys的稀疏矩阵字典. (Dictionary of Keys format) 【功能】创建、转换
lil_matrix ★	【名称】基于行的链表稀疏矩阵 (List of Lists format) 【优点】    ① 快速按行切片    ② 高效地添加、删除、查找元素 【缺点】    ① 按列切片很慢（建议CSC）    ② 算术运算LIL+LIL很慢（考虑CSR或CSC）
csr_matrix	【名称】Compressed Sparse Row format 【优点】    ① 高效的矩阵加法与乘法内积运算    ② 高效的行切片操作    ③ CSR格式在存储稀疏矩阵时非零元素平均使用的字节数(Bytes per Nonzero Entry)最为稳定（float类型约为8.5，double类型约为12.5）CSR格式常用于读入数据后进行稀疏矩阵计算。 【缺点】    ① 列切片操作慢（相比CSC)    ② 转换成稀疏结构成本高（相比LIL)
csc_matrix	【名称】Compressed Sparse Column format 【优点】    ① 高效的矩阵加法与乘法内积运算    ② 高效的列切片操作 【缺点】    ① 矩阵内积操作没有CSR快    ② 行切片操作慢（相比CSR)    ③ 转换成稀疏结构成本高（相比LIL)
bsr_matrix	【名称】Block Sparse Row format
dia_matrix	【名称】DIAgonal format

使用总结

coo_matrix

创建

# 方式一：ijv 创建
>>> data = [5,2,3,0]
>>> row  = [2,2,3,2]
>>> col  = [3,4,2,3]
>>> c = sparse.coo_matrix((data,(row,col)),shape=(5,6))
>>> print(c.toarray())
[[0 0 0 0 0 0]
 [0 0 0 0 0 0]
 [0 0 0 5 2 0]
 [0 0 3 0 0 0]
 [0 0 0 0 0 0]]
 
# 方式二：创建零矩阵
>>> from scipy.sparse import coo_matrix
>>> coo_matrix((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0]], dtype=int8)

# 方式三：创建有重复索引的矩阵
>>> row  = np.array([0, 0, 1, 3, 1, 0, 0])
>>> col  = np.array([0, 2, 1, 3, 1, 0, 0])
>>> data = np.array([1, 1, 1, 1, 1, 1, 1])
>>> coo = coo_matrix((data, (row, col)), shape=(4, 4))
# Duplicate indices are maintained until implicitly or explicitly summed
>>> np.max(coo.data)
1
>>> coo.toarray()
array([[3, 0, 1, 0],
       [0, 2, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 1]])

【预处理】

# 整个过程是为了创建对称矩阵
# coo.T.multiply(coo.T > coo)：找出不对称的正元素,并转置
# -coo.multiply(coo.T > coo)：找出不对称的负元素，并将其删掉
coo = coo + coo.T.multiply(coo.T > coo) - coo.multiply(coo.T > coo)

【保存和读取】

import scipy.sparse as sparse
sparse.save_npz("coo_matrix.npz",coo_save)
coo=sparse.load_npz("coo_matrix.npz")

【转换】

# 转化为其他格式
>>> coo.tocsc()
>>> coo.tocsr()
>>> coo.todense()  # 转化为 numpy.matrix类型

【转置】

# 转置
coo.T

dok_matrix

创建

# 创建
>>> import numpy as np
>>> from scipy.sparse import dok_matrix
>>> S = dok_matrix((5, 5), dtype=np.float32)
>>> for i in range(5):
        for j in range(5):
            S[i, j] = i + j

获取索引

from scipy.sparse import dok_matrix
S=dok_matrix((10,10),dtype=int)
S[1,1]=10
S[1,2]=10
S[1,3]=10
S[1,8]=10
tmp=(S[1,:]==10)
print(tmp.indices)
>>>
	[1 2 3 8]

转换

# convert to coo
S.tocoo()

# convert to numpy
print(S.toarray())
>>> 
[[ 0.  1.  2.  3.  4.]
 [ 1.  2.  3.  4.  5.]
 [ 2.  3.  4.  5.  6.]
 [ 3.  4.  5.  6.  7.]
 [ 4.  5.  6.  7.  8.]]

lil_matrix

【适用的场景】逐渐添加矩阵的元素。
【使用】

from scipy.sparse import lil_matrix
l = lil_matrix((6,5))
l[2,3] = 1
l[3,4] = 2
l[3,2] = 3
print(l.toarray())
>>>
[[ 0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.]
 [ 0.  0.  0.  1.  0.]
 [ 0.  0.  3.  0.  2.]
 [ 0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.]]

# 列求和
print(l.sum(0))
>>> 
	[[0. 0. 3. 1. 2.]]
	
# 行求和
print(l.sum(1))
>>> 
[[0.]
 [0.]
 [1.]
 [5.]
 [0.]
 [0.]]

dia_matrix

【使用】

>>> #data定义对角线元素，在这里是[1,2,3,4]。
>>> data = np.array([[1, 2, 3, 4]]).repeat(3, axis=0)
>>> #offsets定义对角线的偏移量，0代表正对角线，正数代表往上偏移，负数代表往下偏移
>>> offsets = np.array([0, -1, 2])
>>> dia_matrix((data, offsets), shape=(4, 4)).toarray()
array([[1, 0, 3, 0],
       [1, 2, 0, 4],
       [0, 2, 3, 0],
       [0, 0, 3, 4]])

csr_matrix

【使用】

>>> from scipy.sparse import csr_matrix
>>> indptr = np.array([0, 2, 3, 6])
>>> indices = np.array([0, 2, 2, 0, 1, 2])
>>> data = np.array([1, 2, 3, 4, 5, 6])
>>> csr_matrix((data, indices, indptr), shape=(3, 3)).toarray()
array([[1, 0, 2],
       [0, 0, 3],
       [4, 5, 6]])

import numpy as np
from scipy.sparse import csr_matrix
arr = np.array([0, 0, 0, 0, 0, 1, 1, 0, 2])

# 【创建压缩稀疏行】
print(csr_matrix(arr))
 (0, 5)        1 
 (0, 6)        1 
 (0, 8)        2 
 
 #【查看存储的不含0元素的数据】
 print(csr_matrix(arr).data)
 
 #【计算非0元素的总数】
 print(csr_matrix(arr).count_nonzero()) 
 
 #【 删除矩阵中0元素】
 mat = csr_matrix(arr)
 mat.eliminate_zeros()
 
 #【删除重复项】
 mat = csr_matrix(arr)
 mat.sum_duplicates()
 
 #【行压缩(csr)转为列压缩(csc)】
 newarr = csr_matrix(arr).tocsc()

csc_matrix

【说明】压缩稀疏列矩阵(Compressed sparse column matrix)
【使用】

bsr_matrix

【使用】
BSR矩阵中的inptr列表的第i个元素与i+1个元素是储存第i行的数据的列索引以及数据的区间索引，即indices[indptr[i]:indptr[i+1]]为第i行元素的列索引，data[indptr[i]: indptr[i+1]]为第i行元素的data。在下面的例子中，对于第0行，indptr[0]:indptr[1] -> 0:2, 因此第0行的列为indice[0:2]=[0,2],data为data[0:2]=array([[[1, 1],[1, 1]],[[2, 2],[2, 2]]]),对应的就是最后结果的第0,1行.

>>> indptr = np.array([0, 2, 3, 6])
>>> indices = np.array([0, 2, 2, 0, 1, 2])
>>> data = np.array([1, 2, 3, 4, 5, 6]).repeat(4).reshape(6, 2, 2)
>>> bsr_matrix((data,indices,indptr), shape=(6, 6)).toarray()
array([[1, 1, 0, 0, 2, 2],
       [1, 1, 0, 0, 2, 2],
       [0, 0, 0, 0, 3, 3],
       [0, 0, 0, 0, 3, 3],
       [4, 4, 5, 5, 6, 6],
       [4, 4, 5, 5, 6, 6]])