# Sparsereshape — MindSpore Signal+ 使用手册 alpha 文档

# Sparsereshape

对稀疏张量进行形状重塑（Reshape）。该算子将稀疏张量的索引从输入形状转换到输出形状，不改变稀疏值本身，只更新索引。该算子不区分数据类型，只处理索引信息。

对于每个稀疏元素： - 计算其在输入形状中的线性索引：

> \(\text{ori\_index} = \sum_{j=0}^{\text{input\_rank}-1} \text{in\_indices}[j] \times \text{in\_stride}[j]\)

- 将线性索引转换为输出形状的多维索引：

  \(\text{out\_indices}[j] = \text{ori\_index} / \text{out\_stride}[j]\)，然后 \(\text{ori\_index} = \text{ori\_index} \% \text{out\_stride}[j]\)

输入：

  - in_indices_ptr - 输入稀疏张量的索引数组，大小为 N * input_rank，每 input_rank 个元素表示一个非零元素的索引。

  - in_inshape_ptr - 输入稀疏张量的形状数组，大小为 input_rank，例如 [2, 3] 表示 2×3 的矩阵。

  - in_outshape_ptr - 目标输出形状数组，大小为 output_rank，例如 [3, 2] 表示要将形状转换为 3×2。

  - out_outshape_ptr - 输出形状数组，应该与 in_outshape_ptr 一致，大小为 output_rank。

  - input_rank - 输入稀疏张量的维度数。

  - output_rank - 输出稀疏张量的维度数。

  - N - 稀疏张量中非零元素的数量。

  - in_stride - 输入形状的步长数组（临时空间），大小为 input_rank，用于中间计算。

  - out_stride - 输出形状的步长数组（临时空间），大小为 output_rank，用于中间计算。

  - core_mask - 核掩码（仅共享存储版本需要）。

输出：

  - out_indices_ptr - 转换后的索引数组，大小为 N * output_rank，每 output_rank 个元素表示一个非零元素在输出形状中的索引。

支持平台：

  `FT78NE` `MT7004`

备注

- FT78NE 支持fp32

- MT7004 支持fp32

共享存储版本:

void sparsereshape_s(int *in_indices_ptr, int *in_inshape_ptr, int *in_outshape_ptr, int *out_indices_ptr, int *out_outshape_ptr, int input_rank, int output_rank, int N, int *in_stride, int *out_stride, int core_mask)

C调用示例：

     1//FT78NE示例
     2#include <stdio.h>
     3#include <sparsereshape.h>
     4
     5int main(int argc, char* argv[]) {
     6    // 假设在DDR空间
     7    int N = 3;  // 有3个非零元素
     8    int input_rank = 2;  // 输入是2维
     9    int output_rank = 2;  // 输出也是2维
    10
    11    // 输入形状 [2, 3]，输出形状 [3, 2]
    12    int in_inshape[] = {2, 3};
    13    int in_outshape[] = {3, 2};
    14    int out_outshape[] = {3, 2};  // 应该和 in_outshape 一致
    15
    16    // 输入索引：[[0,0], [0,1], [1,2]]
    17    int *in_indices_ptr = (int *)0xA0000000;
    18    in_indices_ptr[0] = 0; in_indices_ptr[1] = 0;  // 第一个元素在位置(0,0)
    19    in_indices_ptr[2] = 0; in_indices_ptr[3] = 1;  // 第二个元素在位置(0,1)
    20    in_indices_ptr[4] = 1; in_indices_ptr[5] = 2;  // 第三个元素在位置(1,2)
    21
    22    // 输出索引（待填充）
    23    int *out_indices_ptr = (int *)0xB0000000;
    24
    25    // 临时空间：步长数组
    26    int *in_stride = (int *)0xC0000000;   // 大小为 input_rank
    27    int *out_stride = (int *)0xC0100000;  // 大小为 output_rank
    28
    29    int core_mask = 0xff;
    30
    31    sparsereshape_s(in_indices_ptr, in_inshape, in_outshape, out_indices_ptr,
    32                   out_outshape, input_rank, output_rank, N, in_stride,
    33                   out_stride, core_mask);
    34
    35    return 0;
    36}

私有存储版本:

void sparsereshape_p(int *in_indices_ptr, int *in_inshape_ptr, int *in_outshape_ptr, int *out_indices_ptr, int *out_outshape_ptr, int input_rank, int output_rank, int N, int *in_stride, int *out_stride)

C调用示例：

     1//FT78NE示例
     2#include <stdio.h>
     3#include <sparsereshape.h>
     4
     5int main(int argc, char* argv[]) {
     6    // 假设在L2空间
     7    int N = 3;
     8    int input_rank = 2;
     9    int output_rank = 2;
    10
    11    int in_inshape[] = {2, 3};
    12    int in_outshape[] = {3, 2};
    13    int out_outshape[] = {3, 2};
    14
    15    int *in_indices_ptr = (int *)0x10000000;
    16    in_indices_ptr[0] = 0; in_indices_ptr[1] = 0;
    17    in_indices_ptr[2] = 0; in_indices_ptr[3] = 1;
    18    in_indices_ptr[4] = 1; in_indices_ptr[5] = 2;
    19
    20    int *out_indices_ptr = (int *)0x10001000;
    21    int *in_stride = (int *)0x10002000;
    22    int *out_stride = (int *)0x10003000;
    23
    24    sparsereshape_p(in_indices_ptr, in_inshape, in_outshape, out_indices_ptr,
    25                   out_outshape, input_rank, output_rank, N, in_stride,
    26                   out_stride);
    27
    28    return 0;
    29}