第十节课的代码

zjhellofss · zjhellofss · commit 8db74b51cb52 · 2023-02-13T08:02:34.000+08:00
diff --git a/include/runtime/runtime_ir.hpp b/include/runtime/runtime_ir.hpp
@@ -26,10 +26,30 @@
 
 // 5. 再把这个runtime_operator存放好
 // 这个runtime_operator中既有输入的参数，又有输出的数、参数，又有层的参数，又有层的权重！
- // 转换成功！
+// 转换成功！
 
 
 namespace kuiper_infer {
+
+class RuntimeGraphShape {
+ public:
+  /**
+   * 如果图是第一次运行，则根据节点输入operand的形状准备好后续Layer计算中所需要的Tensor
+   * 如果图是第二次以上运行，则检查输入operand的形状和operand中张量的形状是否匹配
+   * @param operators 计算图中的计算节点
+   */
+  static void InitOperatorInputTensor(const std::vector<std::shared_ptr<RuntimeOperator>> &operators);
+
+  /**
+   * 如果图是第一次运行，则根据节点输出operand的形状准备好后续Layer计算中所需要的Tensor
+   * 如果图是第二次以上运行，则检查输出operand的形状和operand中张量的形状是否匹配
+   * @param pnnx_operators pnnx图节点
+   * @param operators KuiperInfer计算图中的计算节点
+   */
+  static void InitOperatorOutputTensor(const std::vector<pnnx::Operator *> &pnnx_operators,
+                                       const std::vector<std::shared_ptr<RuntimeOperator>> &operators);
+};
+
 /// 计算图结构，由多个计算节点和节点之间的数据流图组成
 class RuntimeGraph {
  public:
@@ -39,6 +59,13 @@ class RuntimeGraph {
    */
   bool Init();
 
+  /**
+ * 构建计算图
+ * @param input_name 计算图输入节点的名称
+ * @param output_name  计算图输出节点的名称
+ */
+  void Build(const std::string &input_name, const std::string &output_name);
+
   /**
    * 初始化计算图
    * @param param_path 计算图的结构文件
diff --git a/source/runtime/runtime_ir.cpp b/source/runtime/runtime_ir.cpp
@@ -9,6 +9,166 @@
 #include "factory/layer_factory.hpp"
 
 namespace kuiper_infer {
+
+void RuntimeGraphShape::InitOperatorInputTensor(
+    const std::vector<std::shared_ptr<RuntimeOperator>> &operators) {
+  if (operators.empty()) {
+    LOG(ERROR) << "Operators for init input shapes is empty!";
+    return;
+  }
+  for (const auto &op : operators) {
+    if (op->input_operands.empty()) {
+      continue;
+    } else {
+      const std::map<std::string, std::shared_ptr<RuntimeOperand>> &
+          input_operands_map = op->input_operands;
+      for (const auto &input_operand_iter : input_operands_map) {
+        const auto &input_operand = input_operand_iter.second;
+        const auto &type = input_operand->type;
+        CHECK(type == RuntimeDataType::kTypeFloat32)
+                << "The graph only support float32 yet!";
+        const auto &input_operand_shape = input_operand->shapes;
+        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)
+                << "Unsupported tensor shape sizes: " << input_operand_shape.size();
+
+        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));
+            }
+          }
+        } else {
+          input_datas.resize(batch);
+          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));
+            } else if (input_operand_shape.size() == 2) {
+              input_datas.at(i) = std::make_shared<Tensor<float>>(
+                  1, input_operand_shape.at(1), 1);
+            } else {
+              // current shape is 3
+              input_datas.at(i) = std::make_shared<Tensor<float>>(
+                  1, input_operand_shape.at(1), input_operand_shape.at(2));
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+void RuntimeGraphShape::InitOperatorOutputTensor(
+    const std::vector<pnnx::Operator *> &pnnx_operators,
+    const std::vector<std::shared_ptr<RuntimeOperator>> &operators) {
+  CHECK(!pnnx_operators.empty() && !operators.empty());
+  CHECK(pnnx_operators.size() == operators.size());
+  for (uint32_t i = 0; i < pnnx_operators.size(); ++i) {
+    const std::vector<pnnx::Operand *> operands = pnnx_operators.at(i)->outputs;
+    CHECK(operands.size() <= 1) << "Only support one node one output yet!";
+    if (operands.empty()) {
+      continue;
+    }
+    CHECK(operands.size() == 1) << "Only support one output in the KuiperInfer";
+    pnnx::Operand *operand = operands.front();
+    const auto &runtime_op = operators.at(i);
+    CHECK(operand != nullptr) << "Operand output is null";
+    const std::vector<int32_t> &operand_shapes = operand->shape;
+    const auto &output_tensors = runtime_op->output_operands;
+
+    const int32_t batch = operand_shapes.at(0);
+    CHECK(batch >= 0) << "Dynamic batch size is not supported!";
+    CHECK(operand_shapes.size() == 2 || operand_shapes.size() == 4 ||
+        operand_shapes.size() == 3)
+            << "Unsupported shape sizes: " << operand_shapes.size();
+
+    if (!output_tensors) {
+      std::shared_ptr<RuntimeOperand> output_operand =
+          std::make_shared<RuntimeOperand>();
+      output_operand->shapes = operand_shapes;
+      output_operand->type = RuntimeDataType::kTypeFloat32;
+      output_operand->name = operand->name + "_output";
+      for (int j = 0; j < batch; ++j) {
+        if (operand_shapes.size() == 4) {
+          output_operand->datas.push_back(std::make_shared<Tensor<float>>(
+              operand_shapes.at(1), operand_shapes.at(2),
+              operand_shapes.at(3)));
+        } else if (operand_shapes.size() == 2) {
+          output_operand->datas.push_back(
+              std::make_shared<Tensor<float>>(1, operand_shapes.at(1), 1));
+        } else {
+          // current shape is 3
+          output_operand->datas.push_back(std::make_shared<Tensor<float>>(
+              1, operand_shapes.at(1), operand_shapes.at(2)));
+        }
+      }
+      runtime_op->output_operands = std::move(output_operand);
+    } else {
+      CHECK(batch == output_tensors->datas.size());
+      // output_tensors empty
+      CHECK(output_tensors->type == RuntimeDataType::kTypeFloat32);
+      CHECK(output_tensors->shapes == operand_shapes);
+      for (uint32_t b = 0; b < batch; ++b) {
+        const std::vector<uint32_t> &tensor_shapes =
+            output_tensors->datas.at(b)->shapes();
+        if (operand_shapes.size() == 4) {
+          if (tensor_shapes.at(0) != operand_shapes.at(1) ||
+              tensor_shapes.at(1) != operand_shapes.at(2) ||
+              tensor_shapes.at(2) != operand_shapes.at(3)) {
+            DLOG(WARNING) << "The shape of tensor do not adapting with output operand";
+            const auto &target_shapes = std::vector<uint32_t>{(uint32_t) operand_shapes.at(1),
+                                                              (uint32_t) operand_shapes.at(2),
+                                                              (uint32_t) operand_shapes.at(3)};
+            output_tensors->datas.at(b)->ReRawshape(target_shapes);
+          }
+        } else if (operand_shapes.size() == 2) {
+          if (tensor_shapes.at(0) != 1 ||
+              tensor_shapes.at(1) != operand_shapes.at(1) ||
+              tensor_shapes.at(2) != 1) {
+            DLOG(WARNING) << "The shape of tensor do not adapting with output operand";
+            const auto &target_shapes = std::vector<uint32_t>{1, (uint32_t) operand_shapes.at(1), 1};
+            output_tensors->datas.at(b)->ReRawshape(target_shapes);
+          }
+        } else {
+          // current shape is 3
+          if (tensor_shapes.at(0) != 1 ||
+              tensor_shapes.at(1) != operand_shapes.at(1) ||
+              tensor_shapes.at(2) != operand_shapes.at(2)) {
+            DLOG(WARNING) << "The shape of tensor do not adapting with output operand";
+            const auto &target_shapes =
+                std::vector<uint32_t>{1, (uint32_t) operand_shapes.at(1), (uint32_t) operand_shapes.at(2)};
+            output_tensors->datas.at(b)->ReRawshape(target_shapes);
+          }
+        }
+      }
+    }
+  }
+}
+
 RuntimeGraph::RuntimeGraph(std::string param_path, std::string bin_path)
     : param_path_(std::move(param_path)), bin_path_(std::move(bin_path)) {
 
@@ -242,4 +402,34 @@ void RuntimeGraph::InitGraphAttrs(const std::map<std::string, pnnx::Attribute> &
 const std::vector<std::shared_ptr<RuntimeOperator>> RuntimeGraph::operators() const {
   return this->operators_;
 }
+
+void RuntimeGraph::Build(const std::string &input_name, const std::string &output_name) {
+  if (graph_state_ == GraphState::NeedInit) {
+    bool init_graph = Init();
+    LOG_IF(FATAL, !init_graph) << "Init graph failed!";
+  }
+
+  CHECK(graph_state_ >= GraphState::NeedBuild)
+          << "Graph status error, current state is " << int(graph_state_);
+  LOG_IF(FATAL, this->operators_.empty())
+          << "Graph operators is empty, may be no init";
+
+  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") {
+      this->output_operators_maps_.insert({kOperator->name, kOperator});
+    } else {
+      // 以后的课中加layer的
+    }
+  }
+  RuntimeGraphShape::InitOperatorInputTensor(operators_);
+  RuntimeGraphShape::InitOperatorOutputTensor(graph_->ops, operators_);
+  graph_state_ = GraphState::Complete;
+  input_name_ = input_name;
+  output_name_ = output_name;
+}
 }
diff --git a/test/test_init_inoutput.cpp b/test/test_init_inoutput.cpp
@@ -0,0 +1,28 @@
+//
+// Created by yizhu on 2023/2/13.
+//
+#include <glog/logging.h>
+#include <gtest/gtest.h>
+#include "runtime/runtime_ir.hpp"
+
+TEST(test_initinoutput, init_init_input) {
+  using namespace kuiper_infer;
+  const std::string &param_path = "./tmp/test.pnnx.param";
+  const std::string &bin_path = "./tmp/test.pnnx.bin";
+  RuntimeGraph graph(param_path, bin_path);
+  graph.Init();
+  const auto operators = graph.operators();
+  for (const auto &operator_ : operators) {
+    LOG(INFO) << "type: " << operator_->type << " name: " << operator_->name;
+    const std::map<std::string, std::shared_ptr<RuntimeOperand>> &
+        input_operands_map = operator_->input_operands;
+    for (const auto &input_operand : input_operands_map) {
+      LOG(INFO) << "operand name: " << input_operand.first << " operand shape: ";
+      for (const auto &dim : input_operand.second->shapes) {
+        LOG(INFO) << dim << " ";
+      }
+    }
+  }
+
+  LOG(INFO) << "---------------------------------------";
+}
