Merge remote-tracking branch 'upstream/master' into mbencer/ReshapeAdditionalUnitTest

Author: mbencer

compiler/luci-interpreter/src/kernels/Gather.cpp

@@ -55,7 +55,14 @@ void Gather::configure()
   // refer tensorflow/lite/kernels/gather.cc
 
   const Shape &params_shape = params()->shape();
-  const Shape &indices_shape = indices()->shape();
+  Shape indices_shape = indices()->shape();
+  {
+    // scalar index is treated as a tensor with the shape of [1]
+    if (indices_shape.num_dims() == 0)
+    {
+      indices_shape = Shape({1});
+    }
+  }
 
   int axis = _params.axis;
   if (axis < 0)

compiler/luci-interpreter/src/kernels/Gather.test.cpp

@@ -62,6 +62,32 @@ TEST_F(GatherTest, Simple)
   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({1, 4}));
 }
 
+TEST_F(GatherTest, Scalar_Index)
+{
+  std::vector<float> params_data{1.f, 2.f, 3.f, 4.f, 5.f, 6.f};
+  std::vector<int32_t> indices_data{1};
+  std::vector<float> ref_output_data{2.f};
+
+  Tensor params_tensor =
+    makeInputTensor<DataType::FLOAT32>({1, 1, 6}, params_data, _memory_manager.get());
+  Tensor indices_tensor =
+    makeInputTensor<DataType::S32>(/* scalar */ {}, indices_data, _memory_manager.get());
+  Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
+  GatherParams gparams;
+
+  gparams.axis = 2;
+  gparams.batch_dims = 0;
+
+  Gather kernel(&params_tensor, &indices_tensor, &output_tensor, gparams);
+  kernel.configure();
+  _memory_manager->allocate_memory(output_tensor);
+  kernel.execute();
+
+  EXPECT_THAT(extractTensorData<float>(output_tensor),
+              ::testing::ElementsAreArray(ref_output_data));
+  EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({1, 1, 1}));
+}
+
 TEST_F(GatherTest, Simple_Batch)
 {
   Shape params_shape = {3, 5};

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

@@ -210,6 +210,10 @@ loco::TensorShape Algorithm::visit(const luci::CircleReshape *node)
     }
     if (unknown_dim_index != UINT32_MAX)
     {
+      if (input_element_count % output_element_count != 0)
+      {
+        INTERNAL_EXN("Reshape Op cannot infer unknown dimension from inputs.");
+      }
       output_shape.dim(unknown_dim_index) = input_element_count / output_element_count;
     }
   }

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

@@ -162,6 +162,32 @@ TEST(ShapeRuleTest, reshape_zero_rank_mismatch_NEG)
   ASSERT_THROW(shape_inf_rule.infer(node_reshape, output_shape), oops::InternalExn);
 }
 
+TEST(ShapeRuleTest, reshape_wrong_target_shape_NEG)
+{
+  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>();
+
+  tensor_input->dtype(loco::DataType::S32);
+  tensor_input->shape({2, 4});
+  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) = 6;
+  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);
+
+  loco::TensorShape output_shape;
+  luci::sinf::Rule shape_inf_rule;
+
+  ASSERT_THROW(shape_inf_rule.infer(node_reshape, output_shape), oops::InternalExn);
+}
+
 TEST(ShapeRuleTest, reshape_by_input_node)
 {
   auto g = loco::make_graph();