[SubGraph] default graph-related Bugfix; updating unittest

- This patch fixes default-graph-related bugs.
- This patch update unittests
- This patch adds some codes to print `subgraph` info in summarize()

Signed-off-by: Eunju Yang <[email protected]>

Author: EunjuYang

nntrainer/graph/network_graph.h

@@ -72,6 +72,8 @@ class NetworkGraph {
      */
     auto sg = std::make_shared<SubGraphNode>(tensor_manager);
     sg->setName("default");
+    sg->setSubGraphInfo(tensor_manager, exec_mode, lookahead, tensor_format,
+                        tensor_dtype_str);
     graph.addNode(SGNODE(sg));
   }
 
@@ -144,6 +146,16 @@ class NetworkGraph {
    */
   ~NetworkGraph() = default;
 
+  /**
+   * @brief getter of SubGraphNode
+   */
+  std::shared_ptr<SubGraphNode> getSubGraph(const std::string &name) {
+    if (!graph.verifyNode(name))
+      return nullptr;
+    else
+      return SGNODE(graph.getNode(name));
+  }
+
   /**
    * @brief     Realize the network's internal layers
    */

nntrainer/graph/subgraph_node.h

@@ -931,7 +931,8 @@ std::unique_ptr<SubGraphNode>
 createSubGraphNode(std::unique_ptr<nntrainer::SubGraphNode> &&subgraph,
                    const std::vector<std::string> &properties);
 
-SubGraphType createSubGraph(const std::vector<std::string> &properties = {});
+std::shared_ptr<SubGraphNode>
+createSubGraph(const std::vector<std::string> &properties = {});
 
 bool is_representation_equal(const GraphLayerNodeRepresentation &lhs,
                              const GraphLayerNodeRepresentation &rhs);

nntrainer/models/neuralnet.cpp

@@ -1112,12 +1112,23 @@ int NeuralNetwork::addSubGraph(SubGraphType subgraph) {
   // Check the subgraph exists and create a new subgraph if not
   const auto &subgraph_name = subgraph->getName();
   if (graph_map.find(subgraph_name) == graph_map.end()) {
+
+    /**
+     * @note Code to handle `default` graph
+     * This is undesirable way to handle `default` graph, but it is necessary to
+     * support legacy unittests.
+     * @todo update `NetworkGraph` not to create default subgraph in
+     * constructor. Then, this codeblock should be updated as well.
+     */
+    if (model_graph.getSubGraph(subgraph_name) != nullptr)
+      return ML_ERROR_INVALID_PARAMETER;
+
     graph_representation.push_back(subgraph);
     graph_map[subgraph_name] = subgraph;
+    model_graph.addSubGraph(subgraph);
 
     // Insert the layers in subgraph to the graph
     for (auto layer : subgraph->getLayerNodes()) {
-      model_graph.addLayer(layer);
       graph_ln_representation.push_back(layer);
     }
   } else {
@@ -1137,16 +1148,26 @@ int NeuralNetwork::addLayer(NodeType layer) {
   /** Check the subgraph exists and create a new subgraph if not */
   const auto &subgraph_name = layer->getSubGraphName();
   if (graph_map.find(subgraph_name) == graph_map.end()) {
-    const auto &sg = createSubGraph();
-    sg->setName(subgraph_name);
+
+    /**
+     * @note Code to handle `default` graph
+     * This is undesirable way to handle `default` graph, but it is necessary to
+     * support legacy unittests.
+     * @todo update `NetworkGraph` not to create default subgraph in
+     * constructor. Then, this codeblock should be updated as well.
+     */
+    auto sg = model_graph.getSubGraph(subgraph_name);
+    if (sg == nullptr) {
+      sg = createSubGraph();
+      sg->setName(subgraph_name);
+    }
     graph_representation.push_back(sg);
     graph_map[subgraph_name] = sg;
   }
 
   /** Insert the layer to the graph */
   model_graph.addLayer(layer);
   graph_ln_representation.push_back(layer);
-  graph_map[subgraph_name]->addLayer(layer);
 
   return status;
 }
@@ -1375,6 +1396,9 @@ void NeuralNetwork::print(std::ostream &out, unsigned int flags,
 
       for (auto sg_iter = model_graph.cbegin(); sg_iter != model_graph.cend();
            ++sg_iter) {
+        print_graph_layer_info(
+          out, {"<" + sg_iter->getName() + ">", sg_iter->getType(), "", ""});
+        out << std::string(total_col_size, '.') << '\n';
         for (auto iter = sg_iter->cbegin(); iter != sg_iter->cend(); ++iter) {
           std::string first_dim;
           if (iter->getOutputDimensions().empty()) {
@@ -1414,6 +1438,9 @@ void NeuralNetwork::print(std::ostream &out, unsigned int flags,
 
       for (auto sg_iter = model_graph.cbegin(); sg_iter != model_graph.cend();
            ++sg_iter) {
+        print_graph_layer_info(
+          out, {"<" + sg_iter->getName() + ">", sg_iter->getType(), "", ""});
+        out << std::string(total_col_size, '.') << '\n';
         for (auto iter = sg_iter->cbegin(); iter != sg_iter->cend(); ++iter) {
           const std::vector<std::string> &input_layer_names =
             iter->getInputConnections();

nntrainer/models/neuralnet.h

@@ -703,11 +703,21 @@ s   * @retval shared_ptr<const Tensor>
 
   AppContext app_context; /** Configurations bound to current app */
 
+  /**
+   * @note model_graph - updated to reflect the changes made to the graph
+   * It will recreated when compile() is called.
+   */
   NetworkGraph model_graph; /** Network Model Graph */
+
+  /**
+   * @note _represemtation - updated to reflect the changes made to the graph
+   * It saves the node information when addSubGraph / addLayer is called.
+   * This info will be used in compilation time
+   */
   GraphRepresentation
     graph_representation; /** Unsorted subgraph representation */
   std::unordered_map<std::string, SubGraphType>
-    graph_map; /** hashmap for the graph */
+    graph_map; /** hashmap for the graph - shofrtcut for graph_representation */
   GraphLayerNodeRepresentation
     graph_ln_representation; /** Unsorted graph representation with successive
                                 layer nodes */

test/unittest/unittest_nntrainer_subgraph.cpp

@@ -98,26 +98,77 @@ TEST(nntrainer_SubGraph, create_subgraph_02_p) {
 }
 
 /**
- * @brief Unittest to create a subgraph with layers
- * create a graph
+ * @brief Unittest for `addSubGraph`
  */
-TEST(nntrainer_SubGraph, create_subgraph_03_p) {
+TEST(nntrainer_SubGraph, add_subgraph_01_p) {
+  static auto &ac = nntrainer::AppContext::Global();
+  std::shared_ptr<ml::train::Model> model =
+    ml::train::createModel(ml::train::ModelType::NEURAL_NET);
+  std::shared_ptr<ml::train::SubGraph> sg =
+    ml::train::createSubGraph("subgraph", {"subgraph_name=graph0"});
+  EXPECT_EQ(sg->getName(), "graph0");
+  EXPECT_EQ(model->addSubGraph(sg), ML_ERROR_NONE);
+}
+
+/**
+ * @brief Test to add multiple subgraphs.
+ */
+TEST(nntrainer_SubGraph, add_subgraph_02_p) {
+  static auto &ac = nntrainer::AppContext::Global();
+  std::shared_ptr<ml::train::Model> model =
+    ml::train::createModel(ml::train::ModelType::NEURAL_NET);
+
+  std::vector<std::shared_ptr<ml::train::SubGraph>> subgraphs;
+  for (int i = 0; i < 5; ++i)
+    subgraphs.push_back(ml::train::createSubGraph(
+      ml::train::SubGraphType::SUBGRAPH_CPU,
+      {withKey("subgraph_name", "subgraph_" + std::to_string(i))}));
+
+  for (int i = 0; i < 5; ++i)
+    EXPECT_EQ(model->addSubGraph(subgraphs[i]), ML_ERROR_NONE);
+  model->summarize(std::cout, ml_train_summary_type_e::ML_TRAIN_SUMMARY_MODEL);
+  subgraphs.clear();
+}
+
+/**
+ * @brief Negative unittest for `addSubGraph`
+ * @note Please note that model create `default` subgraph by default
+ */
+TEST(nntrainer_SubGraph, add_subgraph_01_n) {
   static auto &ac = nntrainer::AppContext::Global();
 
-  // subgraph named `default`
   std::shared_ptr<ml::train::Model> model1 =
     ml::train::createModel(ml::train::ModelType::NEURAL_NET);
-  model1->addSubGraph(ml::train::createSubGraph("subgraph"));
-  model1->addLayer(ml::train::createLayer(
-    "fully_connected", {withKey("name", "fc0"), withKey("unit", 2)}));
 
-  // subgraph named `default`
-  std::shared_ptr<ml::train::Model> model2 =
+  // subgraph named `default` <- invalid
+  // add default SubGraph returns ML_ERROR_INVALID_PARAMETER
+  EXPECT_EQ(model1->addSubGraph(ml::train::createSubGraph("subgraph")),
+            ML_ERROR_INVALID_PARAMETER);
+  EXPECT_EQ(model1->addSubGraph(
+              ml::train::createSubGraph(ml::train::SubGraphType::SUBGRAPH_CPU)),
+            ML_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @brief Test to add multiple subgraphs with same name.
+ * error handling sohlud be done.
+ */
+TEST(nntrainer_SubGraph, add_subgraph_02_n) {
+  static auto &ac = nntrainer::AppContext::Global();
+  std::shared_ptr<ml::train::Model> model =
     ml::train::createModel(ml::train::ModelType::NEURAL_NET);
-  model2->addLayer(ml::train::createLayer(
-    "fully_connected", {withKey("name", "fc0"), withKey("unit", 2)}));
 
-  EXPECT_EQ(*NNPTR(model1) == *NNPTR(model2), true);
+  std::vector<std::shared_ptr<ml::train::SubGraph>> subgraphs;
+  for (int i = 0; i < 5; ++i)
+    subgraphs.push_back(
+      ml::train::createSubGraph(ml::train::SubGraphType::SUBGRAPH_CPU,
+                                {withKey("subgraph_name", "subgraph")}));
+
+  EXPECT_EQ(model->addSubGraph(subgraphs[0]), ML_ERROR_NONE);
+  for (int i = 1; i < 5; ++i)
+    EXPECT_EQ(model->addSubGraph(subgraphs[i]), ML_ERROR_INVALID_PARAMETER);
+
+  subgraphs.clear();
 }
 
 /**
@@ -130,7 +181,7 @@ TEST(nntrainer_SubGraph, create_subgraph_04_p) {
   std::shared_ptr<ml::train::Model> model1 =
     ml::train::createModel(ml::train::ModelType::NEURAL_NET);
   std::shared_ptr<ml::train::SubGraph> sg =
-    ml::train::createSubGraph("subgraph");
+    ml::train::createSubGraph("subgraph", {"subgraph_name=graph0"});
   // 2. add three layers to subgraph
   sg->addLayer(ml::train::createLayer(
     "fully_connected", {withKey("name", "fc0"), withKey("unit", 2)}));
@@ -140,6 +191,7 @@ TEST(nntrainer_SubGraph, create_subgraph_04_p) {
     "fully_connected", {withKey("name", "fc2"), withKey("unit", 2)}));
   // 3. add a subgraph to model
   model1->addSubGraph(sg);
+  model1->summarize(std::cout, ml_train_summary_type_e::ML_TRAIN_SUMMARY_MODEL);
 
   // add three layers to model directly
   // It implies a default subgraph creation and adding layers to the defulat
@@ -152,8 +204,12 @@ TEST(nntrainer_SubGraph, create_subgraph_04_p) {
     "fully_connected", {withKey("name", "fc1"), withKey("unit", 2)}));
   model2->addLayer(ml::train::createLayer(
     "fully_connected", {withKey("name", "fc2"), withKey("unit", 2)}));
+  model2->summarize(std::cout, ml_train_summary_type_e::ML_TRAIN_SUMMARY_MODEL);
 
-  EXPECT_EQ(*NNPTR(model1) == *NNPTR(model2), true);
+  EXPECT_EQ(is_representation_equal(NNPTR(model1)->getFlatGraph(),
+                                    NNPTR(model2)->getFlatGraph()),
+            true);
+  EXPECT_EQ(*NNPTR(model1) == *NNPTR(model2), false);
 }
 
 /**
@@ -169,7 +225,8 @@ TEST(nntrainer_SubGraph, create_subgraph_05_n) {
   model1->addSubGraph(ml::train::createSubGraph(
     "subgraph", {withKey("subgraph_name", "graph_1")}));
   model1->addLayer(ml::train::createLayer(
-    "fully_connected", {withKey("name", "fc0"), withKey("unit", 2)}));
+    "fully_connected", {withKey("name", "fc0"), withKey("unit", 2),
+                        withKey("subgraph_name", "graph_1")}));
 
   // subgraph named `default`
   std::shared_ptr<ml::train::Model> model2 =
@@ -179,11 +236,12 @@ TEST(nntrainer_SubGraph, create_subgraph_05_n) {
 
   // not equal model (subgraph name is different)
   EXPECT_EQ(*NNPTR(model1) == *NNPTR(model2), false);
-
-  // layer nodes are equal
   EXPECT_EQ(is_representation_equal(NNPTR(model1)->getFlatGraph(),
                                     NNPTR(model2)->getFlatGraph()),
-            true);
+            false);
+
+  model1->summarize(std::cout, ml_train_summary_type_e::ML_TRAIN_SUMMARY_MODEL);
+  model2->summarize(std::cout, ml_train_summary_type_e::ML_TRAIN_SUMMARY_MODEL);
 }
 
 int main(int argc, char **argv) {