[luci-interpreter] Merge target shape from input node and attribute

This commit improve mechanism of shape inference for Reshape operator.
If some dimension from input node is unknown we are trying to find such information in attribute.

ONE-DCO-1.0-Signed-off-by: Mateusz Bencer <m.bencer@partner.samsung.com>

Author: mbencer

compiler/luci/service/src/Nodes/CircleReshape.cpp

@@ -65,6 +65,25 @@ luci::CircleNode *CloneNodeLet<CN::OPQR>::visit(const luci::CircleReshape *node)
 
 namespace sinf
 {
+namespace
+{
+loco::TensorShape merge_shapes(const loco::TensorShape &base_shape,
+                               const loco::TensorShape &merged_shape)
+{
+  loco::TensorShape result_shape = base_shape;
+  if (base_shape.rank() == merged_shape.rank())
+  {
+    for (int axis = 0; axis < base_shape.rank(); ++axis)
+    {
+      if (!base_shape.dim(axis).known() && merged_shape.dim(axis).known())
+      {
+        result_shape.dim(axis) = merged_shape.dim(axis);
+      }
+    }
+  }
+  return result_shape;
+}
+} // namespace
 
 loco::TensorShape Algorithm::visit(const luci::CircleReshape *node)
 {
@@ -154,7 +173,14 @@ loco::TensorShape Algorithm::visit(const luci::CircleReshape *node)
 
     for (uint32_t axis = 0; axis < shape_by_attr.rank(); ++axis)
     {
-      shape_by_attr.dim(axis) = node->newShape()->dim(axis);
+      if (node->newShape()->dim(axis) > 0)
+      {
+        shape_by_attr.dim(axis) = node->newShape()->dim(axis);
+      }
+      else
+      {
+        shape_by_attr.dim(axis).unset(); // unset means unknown dimension
+      }
     }
   }
 
@@ -165,7 +191,7 @@ loco::TensorShape Algorithm::visit(const luci::CircleReshape *node)
     INFO(l) << "   shape_by_attr : " << shape_by_attr << std::endl;
   }
 
-  loco::TensorShape output_shape = shape_by_input;
+  loco::TensorShape output_shape = merge_shapes(shape_by_input, shape_by_attr);
 
   // One of the dimensions can have special value -1, meaning its actual value should be inferred.
   const auto input = loco::must_cast<luci::CircleNode *>(node->tensor());

compiler/luci/service/src/Nodes/CircleReshape.test.cpp

@@ -197,3 +197,79 @@ TEST(ShapeRuleTest, reshape_by_newShape)
   ASSERT_EQ(2, output_shape.dim(0).value());
   ASSERT_EQ(12, output_shape.dim(1).value());
 }
+
+TEST(ShapeRuleTest, reshape_by_newShape_dynamic)
+{
+  auto g = loco::make_graph();
+  auto node_reshape = g->nodes()->create<luci::CircleReshape>();
+  auto tensor_input = g->nodes()->create<luci::CircleInput>();
+  auto shape_dummy = g->nodes()->create<luci::CircleOutputDummy>();
+
+  tensor_input->dtype(loco::DataType::S32);
+  tensor_input->shape({2, 3, 4});
+  tensor_input->shape_status(luci::ShapeStatus::VALID);
+
+  shape_dummy->dtype(loco::DataType::S32);
+  shape_dummy->shape({});
+  shape_dummy->shape_status(luci::ShapeStatus::VALID);
+
+  node_reshape->tensor(tensor_input);
+  node_reshape->shape(shape_dummy);
+
+  // reshape to {-1, 12}
+  node_reshape->newShape()->rank(2);
+  node_reshape->newShape()->dim(0) = -1;
+  node_reshape->newShape()->dim(1) = 12;
+
+  loco::TensorShape output_shape;
+  luci::sinf::Rule shape_inf_rule;
+
+  ASSERT_TRUE(shape_inf_rule.infer(node_reshape, output_shape));
+
+  ASSERT_EQ(2, output_shape.rank());
+  ASSERT_FALSE(output_shape.dim(0).known());
+  ASSERT_TRUE(output_shape.dim(1).known());
+  ASSERT_EQ(12, output_shape.dim(1).value());
+}
+
+TEST(ShapeRuleTest, merge_shape_from_newShape_and_input_node)
+{
+  auto g = loco::make_graph();
+  auto node_reshape = g->nodes()->create<luci::CircleReshape>();
+  auto tensor_input = g->nodes()->create<luci::CircleInput>();
+  auto shape_by_input = g->nodes()->create<luci::CircleConst>();
+
+  node_reshape->tensor(tensor_input);
+
+  tensor_input->dtype(loco::DataType::S32);
+  tensor_input->shape({2, 3, 4, 5});
+  tensor_input->shape_status(luci::ShapeStatus::VALID);
+
+  shape_by_input->dtype(loco::DataType::S32);
+  shape_by_input->size<loco::DataType::S32>(3);
+  shape_by_input->at<loco::DataType::S32>(0) = 2;
+  shape_by_input->at<loco::DataType::S32>(1) = -1;
+  shape_by_input->at<loco::DataType::S32>(2) = -1;
+  shape_by_input->shape_status(luci::ShapeStatus::VALID);
+
+  node_reshape->tensor(tensor_input);
+  node_reshape->shape(shape_by_input);
+
+  node_reshape->newShape()->rank(3);
+  node_reshape->newShape()->dim(0) = -1; // unknow here but pass by shape_by_input
+  node_reshape->newShape()->dim(1) = 12;
+  node_reshape->newShape()->dim(2) = 5;
+
+  loco::TensorShape output_shape;
+  luci::sinf::Rule shape_inf_rule;
+
+  ASSERT_TRUE(shape_inf_rule.infer(node_reshape, output_shape));
+
+  ASSERT_EQ(3, output_shape.rank());
+  ASSERT_TRUE(output_shape.dim(0).known());
+  EXPECT_EQ(2, output_shape.dim(0).value());
+  ASSERT_TRUE(output_shape.dim(1).known());
+  EXPECT_EQ(12, output_shape.dim(1).value());
+  ASSERT_TRUE(output_shape.dim(2).known());
+  EXPECT_EQ(5, output_shape.dim(2).value());
+}