pytorch笔记：torch.sparse类

已于 2022-10-20 10:27:57 修改
阅读量1w 收藏 46
点赞数 13
分类专栏： pytorch学习
于 2021-10-10 15:18:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40206371/article/details/120686280
版权

PyTorch 稀疏张量 COO格式 矩阵运算 内存效率
关键词由CSDN通过智能技术生成

PyTorch 提供了 torch.Tensor 来表示一个包含单一数据类型元素的多维数组。 默认情况下，数组元素连续存储在内存中，从而可以有效地实现各种数组处理算法，这些算法依赖于对数组元素的快速访问。

 然而，存在一类重要的多维数组，即所谓的稀疏数组，其中数组元素的连续内存存储被证明是次优的。 稀疏数组具有大部分元素为零的特性，这意味着如果仅存储或/和处理非零元素，则可以节省大量内存和处理器资源。 

1 构造稀疏矩阵

import torch
i = torch.LongTensor([[0, 1, 1],[2, 0, 2]])   #row, col
v = torch.FloatTensor([3, 4, 5])    #data
torch.sparse.FloatTensor(i, v, torch.Size([2,3])).to_dense()   #torch.Size
'''
tensor([[0., 0., 3.],
        [4., 0., 5.]])
'''

构造方法和 scipy笔记：scipy.sparse_UQI-LIUWJ的博客-CSDN博客 2.2 coo矩阵 的类似

  • 在 PyTorch 中，稀疏张量的填充值不能明确指定，一般假定为零。
  • 但是，存在可能以不同方式解释填充值的操作。 例如，torch.sparse.softmax() 计算 softmax 时假设填充值为负无穷大。

1.1 稀疏COO tensor

  •  在 COO 格式（coordinate）中，指定的元素存储为元素索引和相应值的元组。 
    • 元素索引的类型是torch.int64，size是(ndim,nse)
    • 数值类型是任何类型，size是(nse,)
import torch

i = [[0, 1, 1],
    [2, 0, 2]]

v =  [3, 4, 5]

s = torch.sparse_coo_tensor(i, v, (2, 3))
s

'''
tensor(indices=tensor([[0, 1, 1],
                       [2, 0, 2]]),
       values=tensor([3, 4, 5]),
       size=(2, 3), nnz=3, layout=torch.sparse_coo)
'''

s.is_sparse
#True

s.layout
#torch.sparse_coo

 x坐标为0，y坐标为2的元素是3；x坐标为1，y坐标为1的元素是4.。。。 

1.1.0 稀疏矩阵转换成正常Tensor

s.to_dense()
'''
tensor([[0, 0, 3],
        [4, 0, 5]])
'''

1.1.1 COO tensor和正常tensor（strided tensor）空间复杂度对比

  • COO tensor：ndim*8*nse+<element_size>*nse
  • 正常tensor: <tensor_size>*<element_size>

  • 举例 一个10,000*10,000的 float32 Tensor，其中有100,000个非零元素
    • 正常Tensor的话，需要10 000 * 10 000 * 4 = 400 000 000 比特
    • 使用COO tensor的话，需要(2 * 8 + 4) * 100 000 = 2 000 000比特

1.2.3 创建空的COO tensor

torch.sparse_coo_tensor(size=(2, 3))
'''
tensor(indices=tensor([], size=(2, 0)),
       values=tensor([], size=(0,)),
       size=(2, 3), nnz=0, layout=torch.sparse_coo)
'''

1.2.4 混合稀疏COO Tensor

  • 我们可以将前面value值为标量的稀疏张量扩展到value值为连续张量的稀疏张量。
  • 这种张量称为混合张量。
    • 元素索引的类型是torch.int64，size是(ndim,nse)
    • 数值类型是任何类型，size是(nse,dense_dims)
  • 对应的稀疏矩阵的维度是n_dim+dense_dims
import torch

i = [[0, 1, 1],
    [2, 0, 2]]

v =  [[3,2],[4,1],[5,3]]

s = torch.sparse_coo_tensor(i, v, (2, 3,2))
s,s.to_dense()

'''
(tensor(indices=tensor([[0, 1, 1],
                        [2, 0, 2]]),
        values=tensor([[3, 2],
                       [4, 1],
                       [5, 3]]),
        size=(2, 3, 2), nnz=3, layout=torch.sparse_coo),
 tensor([[[0, 0],
          [0, 0],
          [3, 2]],
 
         [[4, 1],
          [0, 0],
          [5, 3]]]))
'''

1.2.5 未合并的稀疏COO 张量

  • PyTorch 稀疏 COO 张量格式允许未合并的稀疏张量，其中索引中可能存在重复坐标；
  • 在这种情况下，该索引处的值是所有重复值条目的总和。
  • 例如，可以为同一个索引 1 指定多个值 3 和 4，这会导致未合并张量：
i = [[1, 1]]
v =  [3, 4]
s=torch.sparse_coo_tensor(i, v, (3,))
s
'''
tensor(indices=tensor([[1, 1]]),
       values=tensor([3, 4]),
       size=(3,), nnz=2, layout=torch.sparse_coo)
'''
s.is_coalesced()
#False

合并（结果仍为稀疏张量） 

s.coalesce()
'''
tensor(indices=tensor([[1]]),
       values=tensor([7]),
       size=(3,), nnz=1, layout=torch.sparse_coo)
'''
s.coalesce().is_coalesced()
# True
s.to_dense()
#tensor([0, 7, 0])

1.2.6 是否需要合并？ 

  •  在大多数情况下，不用关心稀疏张量是否被合并，因为在给定合并或未合并稀疏张量的情况下，大多数操作的工作方式相同。
  • 但是，一些操作可以在未合并的张量上更有效地实现，而一些操作可以在合并的张量上更有效地实现。
  • 例如，通过简单地连接索引和值张量来实现稀疏 COO 张量的添加：
a = torch.sparse_coo_tensor([[1, 1]], [5, 6], (2,))
b = torch.sparse_coo_tensor([[0, 0]], [7, 8], (2,))
a + b
'''
tensor(indices=tensor([[0, 0, 1, 1]]),
       values=tensor([7, 8, 5, 6]),
       size=(2,), nnz=4, layout=torch.sparse_coo)
'''

1.2.7 查看indice和value

1）不用事先合并

import torch

i = [[0, 1, 1],
    [2, 0, 2]]

v =  [3, 4, 5]

s = torch.sparse_coo_tensor(i, v, (2, 3))
print(s)
print(s._indices())
print(s._values())

'''
tensor(indices=tensor([[0, 1, 1],
                       [2, 0, 2]]),
       values=tensor([3, 4, 5]),
       size=(2, 3), nnz=3, layout=torch.sparse_coo)
tensor([[0, 1, 1],
        [2, 0, 2]])
tensor([3, 4, 5])
'''

 2) 需要事先合并

print(s.indices())
print(s.values())

'''
RuntimeError                              Traceback (most recent call last)
<ipython-input-27-b4753553cd54> in <module>
      8 s = torch.sparse_coo_tensor(i, v, (2, 3))
      9 print(s)
---> 10 print(s.indices())
     11 print(s.values())

RuntimeError: Cannot get indices on an uncoalesced tensor, please call .coalesce() first
'''
print(s.coalesce().indices())
print(s.coalesce().values())
'''
tensor(indices=tensor([[0, 1, 1],
                       [2, 0, 2]]),
       values=tensor([3, 4, 5]),
       size=(2, 3), nnz=3, layout=torch.sparse_coo)
tensor([[0, 1, 1],
        [2, 0, 2]])
tensor([3, 4, 5])
'''

 1.2.6 sparse_dim 和dense_dim

一个是index的dim，一个是value的dim

import torch

i = [[0, 1, 1],
    [2, 0, 2]]

v =  [3, 4, 5]

s = torch.sparse_coo_tensor(i, v, (2, 3))
print(s.sparse_dim(),s.dense_dim())
#（2,0）

 

i = [[0, 1, 1],
    [2, 0, 2]]

v =  [[3,2],[4,1],[5,3]]

s = torch.sparse_coo_tensor(i, v, (2, 3,2))
print(s.sparse_dim(),s.dense_dim())
#(2,1)

1.2.7 切片和索引

i = [[0, 1, 1],
    [2, 0, 2]]

v =  [[3,2],[4,1],[5,3]]

s = torch.sparse_coo_tensor(i, v, (2, 3,2))
print(s)
'''
tensor(indices=tensor([[0, 1, 1],
                       [2, 0, 2]]),
       values=tensor([[3, 2],
                      [4, 1],
                      [5, 3]]),
       size=(2, 3, 2), nnz=3, layout=torch.sparse_coo)
'''

 在sparse维度（index部分）和dense部分（value部分）都可以索引

s[1]
'''
tensor(indices=tensor([[0, 1, 1],
                       [2, 0, 2]]),
       values=tensor([[3, 2],
                      [4, 1],
                      [5, 3]]),
       size=(2, 3, 2), nnz=3, layout=torch.sparse_coo)
'''

s[1,0,1]
#tensor(1)

切片只能在dense部分切 

s[1,0,1:],s[1,0,0:]
#(tensor([1]), tensor([4, 1]))

2 稀疏矩阵的基本运算

基本上都是第一个参数是sparse的，第二个是正常Tensor

先构造两个稀疏矩阵

import torch
i = torch.LongTensor([[0, 1, 1],[2, 0, 2]])   #row, col
v = torch.FloatTensor([3, 4, 5])    #data
x1=torch.sparse.FloatTensor(i, v, torch.Size([2,3]))

x1,x1.to_dense()  
'''
(tensor(indices=tensor([[0, 1, 1],
                        [2, 0, 2]]),
        values=tensor([3., 4., 5.]),
        size=(2, 3), nnz=3, layout=torch.sparse_coo),
 tensor([[0., 0., 3.],
         [4., 0., 5.]]))
'''


import torch
i = torch.LongTensor([[0, 1, 1],[1, 0, 1]])   #row, col
v = torch.FloatTensor([3, 4, 5])    #data
x2=torch.sparse.FloatTensor(i, v, torch.Size([3,2]))

x2,x2.to_dense() 
'''
(tensor(indices=tensor([[0, 1, 1],
                        [1, 0, 1]]),
        values=tensor([3., 4., 5.]),
        size=(3, 2), nnz=3, layout=torch.sparse_coo),
 tensor([[0., 3.],
         [4., 5.],
         [0., 0.]]))
'''

 2.0 不支持dense * sparse！

pytorch不支持M[strided] @ M[sparse_coo]

如果需要，可以这么整：D @ S == (S.t() @ D.t()).t()

2.1 稀疏矩阵的乘法

2.1.1 torch.mm

只支持第二个参数是dense（即dense*dense，或者sparse*dense），输出是dense

dense*dense
dense*sparse
sparse*sparse
sparse*dense

 2.1.2 torch.sparse.mm

 同样地，只支持第二个参数是dense（即dense*dense，或者sparse*dense） 

dense*dense
dense*sparse
sparse*sparse
sparse*dense

2.1.3 torch.mv

矩阵和向量的乘法，第二个也只能是dense的

import torch

i = [[0, 1, 1],
    [2, 0, 2]]

v =  [3, 4, 5]

s = torch.sparse_coo_tensor(i, v, (2, 3))
print(s.to_dense())
'''
tensor([[0, 0, 3],
        [4, 0, 5]])
'''


t=torch.LongTensor([1,2,3])
torch.mv(s,t),s@t
'''
(tensor([ 9, 19]), tensor([ 9, 19]))
'''

2.1.4 torch.matmul

和torch.mm 类似，第二个也是只能dense

import torch

i = [[0, 1, 1],
    [2, 0, 2]]

v =  [3, 4, 5]

s = torch.sparse_coo_tensor(i, v, (2, 3))

t=torch.LongTensor([[1],[2],[3]])
torch.matmul(s,t),s@t

'''
(tensor([[ 9],
         [19]]),
 tensor([[ 9],
         [19]]))
'''

 

2.2 转置

 t()即可

x2,x2.to_dense()
'''
(tensor(indices=tensor([[0, 1, 1],
                        [1, 0, 1]]),
        values=tensor([3., 4., 5.]),
        size=(3, 2), nnz=3, layout=torch.sparse_coo),
 tensor([[0., 3.],
         [4., 5.],
         [0., 0.]]))
'''

x2.t(),x2.t().to_dense()

'''
(tensor(indices=tensor([[1, 0, 1],
                        [0, 1, 1]]),
        values=tensor([3., 4., 5.]),
        size=(2, 3), nnz=3, layout=torch.sparse_coo),
 tensor([[0., 4., 0.],
         [3., 5., 0.]]))
'''

 2.3 索引

稀疏矩阵支持整行索引，支持Sparse.matrix[row_index]；

x2,x2.to_dense()
'''
(tensor(indices=tensor([[0, 1, 1],
                        [1, 0, 1]]),
        values=tensor([3., 4., 5.]),
        size=(3, 2), nnz=3, layout=torch.sparse_coo),
 tensor([[0., 3.],
         [4., 5.],
         [0., 0.]]))
'''

x2[1],x2[1].to_dense()
'''
(tensor(indices=tensor([[0, 1]]),
        values=tensor([4., 5.]),
        size=(2,), nnz=2, layout=torch.sparse_coo),
 tensor([4., 5.]))
'''

稀疏矩阵不支持具体位置位置索引Sparse.matrix[row_index,col_index]

x2[1][1],x2[1][1].to_dense()

 2.4 相加

a = torch.sparse.FloatTensor(
    torch.tensor([[0,1,2],[2,3,4]]), 
    torch.tensor([1,1,1]), 
    torch.Size([5,5]))
a.to_dense()
'''
tensor([[0, 0, 1, 0, 0],
        [0, 0, 0, 1, 0],
        [0, 0, 0, 0, 1],
        [0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0]])
'''

a1=torch.sparse.FloatTensor(
    torch.tensor([[0,3,2],[2,3,2]]), 
    torch.tensor([1,1,1]), 
    torch.Size([5,5]))
a1.to_dense()
'''
tensor([[0, 0, 1, 0, 0],
        [0, 0, 0, 0, 0],
        [0, 0, 1, 0, 0],
        [0, 0, 0, 1, 0],
        [0, 0, 0, 0, 0]])
'''

 只支持sparse+sparse

torch.add(a,a1) ,torch.add(a,a1).to_dense()
'''
(tensor(indices=tensor([[0, 1, 2, 3, 2],
                        [2, 3, 4, 3, 2]]),
        values=tensor([2, 1, 1, 1, 1]),
        size=(5, 5), nnz=5, layout=torch.sparse_coo),
 tensor([[0, 0, 2, 0, 0],
         [0, 0, 0, 1, 0],
         [0, 0, 1, 0, 1],
         [0, 0, 0, 1, 0],
         [0, 0, 0, 0, 0]]))
'''

a.add(a1),a.add(a1).to_dense()
#同理

UQI-LIUWJ
关注
专栏目录
torch_sparse安装
weixin_43030335的博客
08-22 2721
torch_sparse安装
torchsparse：用于点云处理的高性能神经网络库
02-23
火炬稀疏 消息 2020/09/20：我们发布了torchsparse v1.1，该版本明显快于我们的torchsparse v1.0，并且在运行MinkUNet18C时，其速度比 v0.5 alpha快1.9倍！ 2020/08/30：我们发布了torchsparse v1.0。 概述 我们发布了torchsparse ，这是一个用于高效3D稀疏卷积的高性能计算库。 该库旨在加速3D稀疏计算，尤其是稀疏卷积运算。 该库的主要优点是我们支持GPU上的所有计算，尤其是内核映射构造（这是在最新的 V0.4.3中的CPU上完成的）。 安装 您可以运行以下命令来安装torchsparse。 pip install --upgrade git+https://github.com/mit-han-lab/torchsparse.git 请注意，该库取决于Google的。 为了安装该库，您可以
PyTorch Sparse 安装与配置完全指南
最新发布
gitblog_09379的博客
09-13 424
PyTorch Sparse 安装与配置完全指南 pytorch_sparse PyTorch Extension Library of Optimized Autograd Sparse Matrix Operations 项目...
【稀疏矩阵】使用torch.sparse模块
在这里你甚至能学算卦，快进来看看
09-04 1459
目前，torch.sparse和scipy.sparse模块比较支持的主流的稀疏矩阵格式有coo格式、csr格式和csc格式，这三种格式中可供使用的API也最多。需要注意的是，使用操作符在稀疏张量和稠密张量之间乘法运算时，返回的都是稠密张量。如果输入的坐标有重复，则创建出的coo张量会自动把坐标重复的元素值相加。中每个元素可以是一个向量，表示对应坐标的稠密张量，因此，创建出的coo张量也多出了一个维度。，否则会报错，返回的稀疏张量的稀疏结构也与输入相同。此外，在进行稀疏与稀疏之间的数学运算时，一定要保证。
pytorch稀疏张量模块torch.sparse详解
热门推荐
zeeq的博客
02-26 1万+
  torch.sparse是一个专门处理稀疏张量的模块。通常，张量会按一定的顺序连续地进行存取。但是，对于一个存在很多空值的稀疏张量来说，顺序存储的效率显得较为低下。因此，pytorch推出了稀疏张量的处理模块。在这里，有意义的值被称为specified elements，而无意义的值（空值，通常为0，但是也可以是其他值）则被称为fill value。只有足够稀疏的张量使用这种方式进行存储才能获得更高的效率。    Sparse COO tensors 1 Coordinate format   这种格式
torch.sparse_coo_tensor
weixin_56515806的博客
07-26 963
size参数表示输出张量的形状，即输出张量的行数和列数。例如，如果输入矩阵是一个4x5的矩阵，但是只有第2行和第4行、第3列和第5列上的元素是非零的，那么输出张量的形状就是(2, 2)。同时，由于只存储了非零元素的位置和值，因此可以节省大量的内存空间。torch.sparse_coo_tensor是PyTorch中的一个稀疏张量类，用于表示稀疏矩阵。indices参数表示非零元素在原矩阵中的位置，即哪些位置是非零的。它的形状为(N, 2),其中。values参数表示非零元素的值，即。它的形状为(N,)。
PyTroch笔记 - 多GPU分布式训练
Mystra
08-22 1035
模型并行：模型较大，拆分为不同模块，放在不同的GPU上运行，在第1个GPU的输出结果，输入到第2个GPU运行，串行。不要把张量当入日志中输出，使用“.item()”转换为python的数据类型。数据并行：数据放在不同的GPU上跑，模型放在同一个GPU上，并行。代码：使用os.envisorn，例如。argparse，从命令行中接收参数，加载完模型数据，可以进行模型的拷贝，(v1.0版本，已经很少使用 )优点：多进程执行多卡训练，效率高。PyTorch分布式训练。(推荐)，简称DDP。判断CUDA是否可用。
需要使用torch_geometric，安装pytorch-sparse失败的解决方案
chen2601379699的博客
11-25 1683
需要使用torch_geometric，安装pytorch-sparse失败的解决方案
pytorch学习笔记一：张量的操作与线性回归
Dear_learner的博客
01-24 1991
目录一、张量的简介1、张量的基本概念2、张量的属性二、张量的创建1、直接创建2、依数值创建3、依概率创建三、张量的操作1、张量的拼接2、张量的切分3、张量的索引4、张量变换5、算术运算6、高级操作四、线性回归模型 一、张量的简介 1、张量的基本概念 张量是一个【多维数组】，它是一个标量、向量、矩阵的高维拓展。 2、张量的属性 在 PyTorch 0.4.0 之前，torch.autograd 包中存在 Variable 这种数据类型，主要是用于封装 Tensor，进行自动求导。Variable 主要包含下
PyTorch | 学习笔记1
happylls666的博客
12-06 452
一.pytorch实现模型训练 1.数据 如何把数据从硬盘读到内存？ 如何组织数据进行训练？图片如何预处理及数据增强？ 2.模型 如何构建模型模块？如何组织复杂网络？ 如何初始化网络参数？如何定义网络层？ 3.损失函数 如何创建损失函数？如何设置损失函数超参数？ 如何选择损失函数？ 4.优化器 如何管理模型参数？如何管理多个参数组实现不同学习率？ 如何调整学习率？ 5.迭代训练 如何观察训练效果？如何绘制loss/accuracy曲线？ 如何用TensorBoard分析？ 6
torch_sparse-0.6.10-cp39-cp39-linux_x86_64whl.zip
01-15
需要配和指定版本torch-1.8.0+cpu使用，请在安装该模块前提前安装官方命令安装torch-1.8.0+cpu
pytorch_sparse:优化的Autograd稀疏矩阵运算的PyTorch扩展库
05-10
PyTorch稀疏 该软件包包括一个小型扩展库，该库具有自动分级支持，可优化稀疏矩阵运算。 该软件包当前包含以下方法： 所有包含的操作都适用于不同的数据类型，并且都针对CPU和GPU实施。 为了避免创建 ，此程序包仅通过将index和value张量作为参数传递（对稀疏张量的操作。 请注意，autograd支持仅包含value ，因为index是离散的，因此不可微分。 安装 二进制文件 我们为所有主要的OS / PyTorch / CUDA组合提供了点胶轮，请参见。 PyTorch 1.8.0 要安装PyTorch 1.8.0的二进制文件，只需运行 pip install torch-scatter torch-sparse -f https://pytorch-geometric.com/whl/torch-1.8.0+${CUDA}.html 其中${CUDA}应该由cpu ， cu
PyTorch笔记 - IMDB数据集文本分类项目模型与训练
Mystra
08-18 2521
IMDB数据集：Kaggle下载地址，影评的积极或消极分类的影评，PyTorch的Dataset：torchtext.datasets.IMDB。
pytorch稀疏矩阵处理（torch.sparse）
magic东的博客
01-25 1万+
本文将简单介绍稀疏矩阵常用的存储方式和Pytorch中稀疏矩阵的处理方式
torchsparse安装
AI_BING_的博客
05-26 8727
torchsparse安装以及安装失败原因分析和解决
torch.spares_coo_tensor
qq_39217312的博客
04-06 1988
此参数是指定非零元素所在的位置，也就是行和列，所以此参数应该是一个二维的数组，当然它可以是很多格式（ist, tuple, NumPy ndarray, scalar, and other types. ）第一维指定了所有非零数所在的行数，第二维指定了所有非零元素所在的列数。使用一个三元组来表示矩阵中的一个非0数，三元组分别表示元素（所在行，所在列，元素值），也就是上图中每一个竖的三元组就是表示了一个非零数，其余值都为0，这样就存储了一个稀疏矩阵。注:如果未指定设备参数，则给定值和索引张量的设备必须匹配。
pytorch_sparse教程
发呆的比目鱼的博客
01-30 1247
pytorch_sparse教程
scipy.sparse转torch.sparse
03-31
scipy.sparse是Python中用于处理稀疏矩阵的库，而torch.sparse是PyTorch中处理稀疏张量的模块。如果你想将scipy.sparse矩阵转换为torch.sparse张量，可以按照以下步骤进行操作： 1. 首先，确保你已经安装了scipy和PyTorch库。 2. 导入所需的库： ```python import scipy.sparse as sp import torch ``` 3. 创建一个scipy.sparse矩阵： ```python sparse_matrix = sp.csr_matrix([[1, 0, 2], [0, 3, 0], [4, 0, 5]]) ``` 4. 将scipy.sparse矩阵转换为torch.sparse张量： ```python torch_sparse_tensor = torch.from_numpy(sparse_matrix.toarray()).to_sparse() ``` 这里使用了`toarray()`方法将稀疏矩阵转换为密集矩阵，然后使用`to_sparse()`方法将密集矩阵转换为稀疏张量。 5. 现在，你可以使用torch_sparse_tensor进行进一步的操作，如传递给PyTorch模型进行训练等。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

UQI-LIUWJ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值