再探Tensor类：

第二节中我们编写的Tensor类其实并不能满足我们的使用需要，我们将在这一节以代码阅读的方式来看看一个完全版本的Tensor应该具备怎样的要素，同时我们对Tensor类的分析来看看在C++中一个设计好的类应该是怎么样的。

Tensor<float>::Tensor(uint32_t channels, uint32_t rows, uint32_t cols) {
  data_ = arma::fcube(rows, cols, channels);
  if (channels == 1 && rows == 1) {
    this->raw_shapes_ = std::vector<uint32_t>{cols};
  } else if (channels == 1) {
    this->raw_shapes_ = std::vector<uint32_t>{rows, cols};
  } else {
    this->raw_shapes_ = std::vector<uint32_t>{channels, rows, cols};
  }
}

在这里，raw_shape记录的是另外一个方面的形状信息，主要用于review和flatten层中。

举一个简单的例子，当Tensor将一个大小为(2,16,1)的Tensor reshape到(32,1,1)的大小时，raw_shapes变量会被记录成(32). 将一个大小为(2,16, 2)的Tensor reshape到(2, 64)的大小时，raw_shapes会被记录成(2,64).

那这样做的目的是什么呢？原来的Tensor不能在逻辑上区分当前的张量是三维的、二维的还是一维的，因为实际的数据存储类arma::fcube总是一个三维数据。所以我们要区分他的逻辑结构，就需要这么一个raw_shape

列优先的Reshape

void Tensor<float>::ReRawshape(const std::vector<uint32_t>& shapes) {
  CHECK(!this->data_.empty());
  CHECK(!shapes.empty());
  const uint32_t origin_size = this->size();
  uint32_t current_size = 1;
  for (uint32_t s : shapes) {
    current_size *= s;
  }
  CHECK(shapes.size() <= 3);
  CHECK(current_size == origin_size);

  if (shapes.size() == 3) {
    this->data_.reshape(shapes.at(1), shapes.at(2), shapes.at(0));
    this->raw_shapes_ = {shapes.at(0), shapes.at(1), shapes.at(2)};
  } else if (shapes.size() == 2) {
    this->data_.reshape(shapes.at(0), shapes.at(1), 1);
    this->raw_shapes_ = {shapes.at(0), shapes.at(1)};
  } else {
    this->data_.reshape(shapes.at(0), 1, 1);
    this->raw_shapes_ = {shapes.at(0)};
  }
}

我们再来分析一下这个函数，如果传入的shapes是1维的，就相当于将数据展开为(elem_size,1,1)，并将逻辑维度赋值为1. 如果传入的shapes，相当于将数据展开为(shapes.at(0), shapes.at(1), 1). 我们来看看下面的这个图例：

如果把上面的(2,2,3)展平为一维的，那就应该是如下图所示：

而且这也是arma:cube的默认排序（列排序）

行优先的Reshape

那如果我们在某些情况下需要行优先的Reshape呢？

void Tensor<float>::ReView(const std::vector<uint32_t>& shapes) {
  CHECK(!this->data_.empty());
  const uint32_t target_channels = shapes.at(0);
  const uint32_t target_rows = shapes.at(1);
  const uint32_t target_cols = shapes.at(2);
  arma::fcube new_data(target_rows, target_cols, target_channels);

  const uint32_t plane_size = target_rows * target_cols;
  for (uint32_t c = 0; c < this->data_.n_slices; ++c) {
    const arma::fmat& channel = this->data_.slice(c);
    for (uint32_t c_ = 0; c_ < this->data_.n_cols; ++c_) {
      const float* colptr = channel.colptr(c_);
      for (uint32_t r = 0; r < this->data_.n_rows; ++r) {
        const uint32_t pos_index =
            c * data_.n_rows * data_.n_cols + r * data_.n_cols + c_;
        const uint32_t ch = pos_index / plane_size;
        const uint32_t row = (pos_index - ch * plane_size) / target_cols;
        const uint32_t col = (pos_index - ch * plane_size - row * target_cols);
        new_data.at(row, col, ch) = *(colptr + r);
      }
    }
  }
  this->data_ = new_data;
}

我们只能通过位置计算的方式来对逐个元素进行搬运，const uint32_t plane_size = target_rows * target_cols;来计算行数和列数相乘的积。

const uint32_t pos_index = c * data_.n_rows * data_.n_cols + r * data_.n_cols + c_; 得到调整前的元素下标，随后我们计算调整后的通道下标位置：ch = pos_index / plane_size，plane_size就是和一面，一行乘一列。同理计算row,col等调整位置后的行、列坐标。

计算图关系

内容回顾

我们在回顾一下之前的内容，我们根据pnnx计算图得到了我们的计算图，我们的计算图由两部分组成，分别是kuiper_infer::RuntimeOperator和kuier_infer::RuntimeOperand.

但是作为一个计算图，计算节点之间往往是有连接的，包括从input operator到第一个计算节点再到第二个计算节点，直到最后的输出节点output operator，我们再来回顾一下这两个数据结构的具体定义：

struct RuntimeOperator {
  int32_t meet_num = 0; /// 计算节点被相连接节点访问到的次数
  ~RuntimeOperator() {
    for (auto &param : this->params) {
      if (param.second != nullptr) {
        delete param.second;
        param.second = nullptr;
      }
    }
  }
  std::string name; /// 计算节点的名称
  std::string type; /// 计算节点的类型
  std::shared_ptr<Layer> layer; /// 节点对应的计算Layer

  std::vector<std::string> output_names; /// 节点的输出节点名称
  std::shared_ptr<RuntimeOperand> output_operands; /// 节点的输出操作数

  std::map<std::string, std::shared_ptr<RuntimeOperand>> input_operands; /// 节点的输入操作数
  std::vector<std::shared_ptr<RuntimeOperand>> input_operands_seq; /// 节点的输入操作数，顺序排列
  std::map<std::string, std::shared_ptr<RuntimeOperator>> output_operators; /// 输出节点的名字和节点对应

  std::map<std::string, RuntimeParameter *> params;  /// 算子的参数信息
  std::map<std::string, std::shared_ptr<RuntimeAttribute> > attribute; /// 算子的属性信息，内含权重信息
};

std::map<:string std::shared_ptr>> output_operators; 我们重点来看这个定义，它是当前这个计算节点的下一个计算节点，当数据在当前RuntimeOperator上计算完成之后，系统会读取output_operators中准备就绪的算子并开始执行。
std::map<:string std::shared_ptr>> input_operands; 是当前计算节点所需要的输入，它往往来自于上一个RuntimeOperator的输入。
std::shared_ptr output_operands; 是当前节点计算得到的输出，它是通过当前的op计算得到的。

具体的流程是这样的，假设我们在系统中有三个RuntimeOperators，分别为op1,op2和op3. 这三个算子的顺序是依次执行的，分别是op1-->op2-->op3.

当我们执行第一个算子op1的时候，需要将来自于图像的输入填充到op1->input_operands中。
第一个算子op1开始执行，执行的过程中读取op1->input_operands并计算得到相关的输出，放入到op1->output_operands中
从op1的output_operators中读取到ready的op2
第二个算子op2开始执行，执行的过程读取op1->output_operands并拷贝op2->input_operands中，随后op2算子开始执行并计算得到相关的输出，放入到op2->output_operands中。

所以我们可以看到者之间是有一个图关系的，那我们来看一下他是怎么构建这样一个图关系的

怎样构建图关系：



/ 构建图关系
  for (const auto &current_op : this->operators_) {
    const std::vector<std::string> &output_names = current_op->output_names;
    for (const auto &next_op : this->operators_) {
      if (next_op == current_op) {
        continue;
      }
      if (std::find(output_names.begin(), output_names.end(), next_op->name) !=
          output_names.end()) {
        current_op->output_operators.insert({next_op->name, next_op});
      }
    }
  }
  ```
  -  **const std::vector\<std::string> &output_names = current_op->output_names;** 存放的是当前`op`的`output_names`，`output_names`也就是当前算子的后一层算子的名字。对于`op1`，它的`output_names`就是`op2`的name.
  - **const auto &next_op : this->operators_**  我们遍历整个图中的`RuntimeOperators`，如果遇到`next_op`的name和当前`current_op->output_name`是一致的，那么我们就可以认为`next_op`是当前`op`的下一个节点之一。
  - **current_op->output_operators.insert({next_op->name, next_op});** 将`next_op`插入到`current_op`的下一个节点当中。
  - 这样一来，当`current_op`执行完成之后就取出`next_op`，并将当前`current_op`的输出`output_opends`（输出）拷贝到`next_op`的`input_operands`（输入）中。

因为在初始化的时候就已经约定好了op1的输出是op2，所以只要在接下来的点中不停地寻找op2就好了，找到了之后就把它insert到output_operators里面.这个output_operators是一个map，就可以让输出节点的名字和节点对应。

这么一个计算图也得有输入输出节点吧

作者：傅大狗
链接：https://zhuanlan.zhihu.com/p/604613883
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

  this->input_operators_maps_.clear();
  this->output_operators_maps_.clear();

  for (const auto &kOperator : this->operators_) {
    if (kOperator->type == "pnnx.Input") {
      this->input_operators_maps_.insert({kOperator->name, kOperator});
    } else if (kOperator->type == "pnnx.Output") {
      if (kOperator->name == output_name) {
        this->output_operators_maps_.insert({kOperator->name, kOperator});
      } else {
        LOG(FATAL) << "The graph has two output operator!";
      }
    } else {
      std::shared_ptr<Layer> layer = RuntimeGraph::CreateLayer(kOperator);
      CHECK(layer != nullptr) << "Layer create failed!";
      if (layer) {
        kOperator->layer = layer;
      }
    }
  }

kOperator->type == "pnnx.Output" 找到this->operators中的输出节点，但是目前Kuiperinfer只支持一个输出节点，其实也可以多输出，作为一个教学框架我实在不想支持这种corner case
同理: kOperator->type == "pnnx.Input" 来找到图中，也就是op list中的输入节点

就是在op3结束之后，我们还要把op3的output_operand复制到输出节点的input_operand里面

初始化输入

struct RuntimeOperand {
  std::string name;                                     /// 操作数的名称
  std::vector<int32_t> shapes;                          /// 操作数的形状
  std::vector<std::shared_ptr<Tensor<float>>> datas;    /// 存储操作数 为什么是vector，因为是一个batch，如果batch是2的话，那就存储的是两个
  RuntimeDataType type = RuntimeDataType::kTypeUnknown; /// 操作数的类型，一般是float
};

可以看到这里的RuntimeOperand::datas就是存储具体数据的地方，我们初始化输入输出的空间也就是要在推理之前先根据shapes来初始化好这里datas的空间

代码位于runtime_ir.cpp的InitOperatorInputTensor中 RuntimeGraphShape::InitOperatorInputTensor(operators_) 这个函数的输入是operator list, 所以将在这个函数中对所有的op进行输入和输出空间的初始化。

得到一个op的输入空间input_operands

const std::map<std::string, std::shared_ptr<RuntimeOperand>> &
            input_operands_map = op->input_operands;

如果初始的是空就continue

for (const auto &op : operators) {
    if (op->input_operands.empty()) {
      continue;
    }

得到input_operands中记录的数据应有大小input_operand_shape和存储数据的变量input_datas

auto &input_datas = input_operand->datas;

CHECK(!input_operand_shape.empty());
const int32_t batch = input_operand_shape.at(0);
CHECK(batch >= 0) << "Dynamic batch size is not supported!";
CHECK(input_operand_shape.size() == 2 ||
      input_operand_shape.size() == 4 ||
      input_operand_shape.size() == 3)

我们需要根据input_operand_shape中记录的大小去初始化input_datas. 而input_operand_shape可能是三维的，二维的以及一维的，如下方所示
input_operand_shape : (batch, elemsize) 一维的
input_operand_shape : (batch, rows,cols) 二维的
input_operand_shape : (batch, rows,cols, channels) 三维的

如果当前input_operand_shape是二维的数据，也就是说输入维度是(batch,rows,cols)的. 我们首先对batch进行遍历，对一个batch的中的数据input_datas= op->input_operand(输入)进行初始化。

input_datas.resize(batch);
for (int32_t i = 0; i < batch; ++i) {
}

在for循环内，它会调用如下的方法去初始化一个二维的张量：

input_datas.at(i) = std::make_shared<Tensor<float>>(1, input_operand_shape.at(1), input_operand_shape.at(2));

这一块不太清楚，我们实际代码看一遍：

          for (int32_t i = 0; i < batch; ++i) {
            if (input_operand_shape.size() == 4) {
              input_datas.at(i) = std::make_shared<Tensor<float>>(
                  input_operand_shape.at(1), input_operand_shape.at(2),
                  input_operand_shape.at(3));

也就是如果是shape == 4 ，那就是三维的，那么1就是channel，2就是row，3就是col

那么如果输入的channel == 1，或者row == 1

Tensor<float>::Tensor(uint32_t channels, uint32_t rows, uint32_t cols) {
  data_ = arma::fcube(rows, cols, channels);
  if (channels == 1 && rows == 1) {
    this->raw_shapes_ = std::vector<uint32_t>{cols};
  } else if (channels == 1) {
    this->raw_shapes_ = std::vector<uint32_t>{rows, cols};
  } else {
    this->raw_shapes_ = std::vector<uint32_t>{channels, rows, cols};
  }
}

那就正好被初始化为了我们之前的raw_shape 这样的一个逻辑维度

这就和我们上面的课程内容对应上了，Tensor<float>原本是一个三维数据，我们怎么在逻辑上给他表现成一个二维的张量呢？这就要用到我们上面说到的raw_shapes了。

调用并初始化一维的数据也同理, 在初始化的过程中会调用(channels==1&&rows==1) 这个条件判断，并将raw_shapes这个维度定义成一维。

input_datas.at(i) = std::make_shared<Tensor<float>>(1, input_operand_shape.at(1), 1)

避免第二次初始化

那么在计算的过程中，我们只需要一次初始化就可以。

所以在第二次遇到她的时候，只需要去检查空间是否发生改变就可以啦

  if (!input_datas.empty()) {
          CHECK(input_datas.size() == batch) << "Batch size is wrong!";
          for (int32_t i = 0; i < batch; ++i) {
            const std::vector<uint32_t> &input_data_shape =
                input_datas.at(i)->shapes();
            CHECK(input_data_shape.size() == 3)
                    << "THe origin shape size of operator input data do not equals "
                       "to three";
            if (input_operand_shape.size() == 4) {
              CHECK(input_data_shape.at(0) == input_operand_shape.at(1) &&
                  input_data_shape.at(1) == input_operand_shape.at(2) &&
                  input_data_shape.at(2) == input_operand_shape.at(3));
            } else if (input_operand_shape.size() == 2) {
              CHECK(input_data_shape.at(1) == input_operand_shape.at(1) &&
                  input_data_shape.at(0) == 1 && input_data_shape.at(2) == 1);
            } else {
              // current shape size = 3
              CHECK(input_data_shape.at(1) == input_operand_shape.at(1) &&
                  input_data_shape.at(0) == 1 &&
                  input_data_shape.at(2) == input_operand_shape.at(2));
            }
          }
        }

              CHECK(input_data_shape.at(0) == input_operand_shape.at(1) &&
                  input_data_shape.at(1) == input_operand_shape.at(2) &&
                  input_data_shape.at(2) == input_operand_shape.at(3));