pytorch 邻接矩阵转稀疏矩阵 (dense matrix to coo matrix)

link之家

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

相关文章推荐

坚强的机器猫 · 亿级流量系统架构之如何支撑百亿级数据的存储与 ...· 1 年前 ·

茫然的青椒 · vue的按钮重置_vue重置按钮_随枫潜入夜 ...· 1 年前 ·

欢快的夕阳 · JAVA动态加载指定路径下的jar - 简书· 1 年前 ·

腼腆的水龙头 · 怎么Java进行MD5摘要加密？_java ...· 1 年前 ·

import torch a = np . array ( [ [ 0 , 1.2 , 0 ] , [ 2 , 3.1 , 0 ] , [ 0.5 , 0 , 0 ] ] ) idx = a . nonzero ( ) # (row, col) data = a [ idx ] # to torch tensor idx_t = torch . LongTensor ( np . vstack ( idx ) ) data_t = torch . FloatTensor ( data ) coo_a = torch . sparse_coo_tensor ( idx_t , data_t , a . shape ) print ( coo_a )

import scipy.sparse as sp
import numpy as np
import torch
a = np.array([[0, 1.2, 0],[2, 3.1, 0],[0.5, 0, 0]])
coo_np = sp.coo_matrix(a)
data = coo_np.data
idx_t = torch.LongTensor(np.vstack((coo_np.row, coo_np.col)))
data_t = torch.FloatTensor(data)
coo_a=torch.sparse_coo_tensor(idx_t,data_t,a.shape)
方法三（从tensor到sparse tensor）：
 
import numpy as np
import torch
a = torch.tensor([[0, 1.2, 0],[2, 3.1, 0],[0.5, 0, 0]])
idx = torch.nonzero(a).T  # 这里需要转置一下
data = a[idx[0],idx[1]]
coo_a = torch.sparse_coo_tensor(idx, data, a.shape)
print(coo_a)
如果想转回dense的tensor：coo_a.to_dense()

                    如何将一个dense矩阵，比如：一个 N×NN \times NN×N 的邻接矩阵a 转成 pytorch的sparse coo 矩阵。方法一：import numpy as npimport torcha = np.array([[0, 1.2, 0],[2, 3.1, 0],[0.5, 0, 0]])idx = a.nonzero() # (row, col)data = a[idx]# to torch tensoridx_t = torch.LongTensor(np.vstac
				用于Pytorch的快速块稀疏矩阵
这个PyTorch扩展使用块稀疏矩阵而不是密集矩阵来替代torch.nn.Linear。
由于您可以用稀疏矩阵直接替换模型中的线性层，因此可以非常轻松地进行稀疏矩阵实验。
该库的目的是表明稀疏矩阵可用于神经网络，而不是密集网络，而不会显着改变精度。
这是个好消息，因为稀疏矩阵可释放空间和计算方面的节省： 50％的稀疏矩阵将仅使用50％的内存，并且理论上将仅使用50％的计算。在这个库中，与天真的实现相比，我们利用Cutlass来提高CUDA性能。但是，由于基于cuBLAS的torch.nn.Linear的优化特性，该库的当前版本仍然较慢，大约降低了2倍（将来可能会有所改进）。
在该库的当前阶段，稀疏矩阵的性能比其优化的密集对等矩阵的性能大约慢2倍（我们希望在将来对此进行改进）。但是，使用稀疏矩阵的性能提高随稀疏度的增加而增加，因此75％的稀疏矩阵的速
				在使用PyG框架的时候，PyG要求输入的是 edge_index 格式，而不是我们所使用的邻接矩阵格式,即N x N。
import scipy.sparse as sp
import numpy as np
import torch
# adj_matrix 是邻接矩阵
tmp_coo = sp.coo_matrix(adj_matrix)
values = tmp_coo.data
indices = np.vstack((tmp_coo.row,tmp_coo.col))
i = torch.Lon
				普通矩阵：
adj <class 'torch.Tensor'> tensor([[10.0527,  0.7901,  4.7365,  ..., -2.9740, -1.2431,  2.6618],
        [ 0.7901,  7.8155,  2.0635,  ..., -0.7821,  0.8580, -1.8541],
        [ 4.7365,  2.0635,  6.2384,  ..., -2.2005, -0.2560,  2.0816],
				https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.coo_matrix.html#scipy.sparse.coo_matrix
https://www.cnblogs.com/datasnail/p/11021835.html
preds = to_numpy(preds)#preds是[2985x16x2]
preds = preds.transpose(2, 1, 0)#preds[2x16x2985]
以上这篇pytorch 转换矩阵的维数位置方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持软件开发网。
                        您可能感兴趣的文章:对pytorch网络层结构的数组化详解pytorch对可变长度序列的处理方法详解pytorch 调整某一维度数据顺序的方法对PyTorch torch.stack的实例讲解使用pytorch进行图像的顺序读
稀疏矩阵指矩阵中的大多数元素的值都为0，由于其中非常多的元素都是0，使用常规方法进行存储非常的浪费空间，所以采用另外的方法存储稀疏矩阵。
Coordinate(COO)格式是用来描述稀疏矩阵一种方法或数据结构。
Coordinate(COO)格式本身是一个矩阵，用COO矩阵，描述另一个目标稀疏矩阵，原理如下：
这是非常简单的一种方式，使用一个三元组构成的三维COO矩阵来描述任意维度的稀疏矩阵。
三元组分别表示稀疏矩阵中的元素（所...
				values =X_train.data
indices = np.vstack((X_train.row, X_train.col))
i = torch.LongTensor(indices)
v = torch.FloatTensor(values)
shape = X_train.shape
X_train=torch.sparse.FloatTensor(i, v, torch.Size(shape))
转换为scipy.sparse：.tocoo（）即可
				刚开始学习图神经网络，在使用PyG框架编程的时候，有一件事很让我纠结：PyG要求输入的邻接矩阵X应该是稀疏矩阵的形式（edge_index），而不是我制作的NxN邻接矩阵形式。
举个简单的例子，看下面这个图结构：
邻接矩阵的创建如下：
A = np.array([0, 1, 0],
			 [1, 0, 1],
			 [0, 1, 0])
A = torch.LongTensor(A)
然后你会发现扔进PyG搭建的GCN模型报错了啊！
ValueError: `MessagePassing.propa
				普通邻接矩阵转换成edge_index的COO稀疏矩阵形式，格式为[2, num_edges]。
平时我们接触的邻接矩阵adj的形式要么是稠密矩阵（原始二维矩阵），但是在使用PyG框架的时候会发现格式不对，需要形式为[2, edges]的coo_matrix。
首先，把adj转为普通的coo_matrix矩阵：
adj = sp.coo_matrix(adj)
(0, 633) 1
(0, 1862) 1
(0, 2582) 1
(0, 2) 1
.   .
.   .
(2707, 165) 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])
scipy.sparse.csc_matrix((data, indices, indptr), shape=(3, 3)).toarray()
output:
array([[...
def normalize_adjacency(adjacency_matrix):
    # 计算每个节点的度
    node_degrees = torch.sum(adjacency_matrix, dim=1)
    # 计算度矩阵的逆矩阵
    degree_matrix = torch.diag(torch.pow(node_degrees, -0.5))
    # 对称归一化邻接矩阵
    normalized_adjacency = torch.matmul(torch.matmul(degree_matrix, adjacency_matrix), degree_matrix)
    return normalized_adjacency
这个函数接受一个邻接矩阵作为输入，并返回归一化后的邻接矩阵。它首先计算每个节点的度，并使用度矩阵的逆矩阵进行归一化。然后，通过将度矩阵的逆矩阵应用于邻接矩阵来实现对称归一化。
请注意，这个代码只适用于无向图。如果你处理的是有向图，可能需要使用不同的归一化方法。