Completely transition of MO to Interpolate-4

docs/ops/image/Interpolate_4.md

@@ -15,6 +15,7 @@
   * **Type**: string
   * **Default value**: none
   * **Required**: *yes*
+  * **Note**: Only 2D and 4D tensors with `axes = {0, 1}` and `axes = {2, 3}` respectively are supported for `"mode" == "linear_onnx"`.
 
 * *shape_calculation_mode*
 

inference-engine/src/transformations/src/transformations/op_conversions/convert_interpolate1_to_interpolate4.cpp

@@ -16,53 +16,61 @@
 NGRAPH_RTTI_DEFINITION(ngraph::pass::ConvertInterpolate1ToInterpolate4, "ConvertInterpolate1ToInterpolate4", 0);
 
 ngraph::pass::ConvertInterpolate1ToInterpolate4::ConvertInterpolate1ToInterpolate4() {
-    MATCHER_SCOPE(ConvertInterpolate1ToInterpolate4);
-    auto interpolate1 = ngraph::pattern::wrap_type<ngraph::opset1::Interpolate>({pattern::any_input(pattern::has_static_rank()), pattern::any_input()});
+    auto interpolate1 = ngraph::pattern::wrap_type<ngraph::opset1::Interpolate>({pattern::any_input(pattern::has_static_shape()), pattern::any_input()});
     ngraph::matcher_pass_callback callback = [this](pattern::Matcher& m) {
-        auto interpolate1 = std::dynamic_pointer_cast<ngraph::opset1::Interpolate>(m.get_match_root());
-        if (!interpolate1)
+        auto interpolationV0 = std::dynamic_pointer_cast<ngraph::opset1::Interpolate>(m.get_match_root());
+        if (!interpolationV0) {
             return false;
+        }
 
-        auto interpolate_attrs = interpolate1->get_attrs();
-        auto input_shape_rank = interpolate1->input(0).get_partial_shape().rank().get_length();
+        auto& inp_partial_shape = interpolationV0->get_input_partial_shape(0);
+        auto& out_shape = interpolationV0->get_output_shape(0);
+        auto attrsV0 = interpolationV0->get_attrs();
 
-        // attrs
-        auto mode_v4 = ngraph::op::v4::Interpolate::InterpolateMode();
-        if (interpolate_attrs.mode == "nearest") {
-            mode_v4 = ngraph::op::v4::Interpolate::InterpolateMode::nearest;
-        } else if (interpolate_attrs.mode == "cubic") {
-            mode_v4 = ngraph::op::v4::Interpolate::InterpolateMode::cubic;
-        } else if (interpolate_attrs.mode == "linear") {
-            if (input_shape_rank < 5) {
-                mode_v4 = ngraph::op::v4::Interpolate::InterpolateMode::linear_onnx;
-            } else if (input_shape_rank == 5) {
-                mode_v4 = ngraph::op::v4::Interpolate::InterpolateMode::linear;
-            } else {
-                return false;
+        std::vector<float> scales(attrsV0.axes.size(), 1.0f);
+        if (inp_partial_shape.is_static()) {
+            auto inp_shape = inp_partial_shape.to_shape();
+            size_t i = 0;
+            for (std::size_t axis : attrsV0.axes) {
+                scales[i] = static_cast<float>(out_shape.at(axis))/inp_shape.at(axis);
+                i++;
             }
+        }
+
+        auto scalesConstant = ngraph::op::Constant::create(ngraph::element::f32, {scales.size()}, scales);
+        auto axisConstant = ngraph::op::Constant::create(ngraph::element::i64, {attrsV0.axes.size()},
+                                                         std::vector<std::size_t>{attrsV0.axes.begin(), attrsV0.axes.end()});
+
+        ngraph::op::v4::Interpolate::InterpolateAttrs attrsV4;
+
+        if (attrsV0.mode == "nearest") {
+            attrsV4.mode = ngraph::opset4::Interpolate::InterpolateMode::nearest;
+        } else if (attrsV0.mode == "linear") {
+            attrsV4.mode = ngraph::opset4::Interpolate::InterpolateMode::linear;
+        } else if (attrsV0.mode == "cubic") {
+            attrsV4.mode = ngraph::opset4::Interpolate::InterpolateMode::cubic;
+        } else if (attrsV0.mode == "linear_onnx") {
+            attrsV4.mode = ngraph::opset4::Interpolate::InterpolateMode::linear_onnx;
         } else {
             return false;
         }
-        auto nearest_mode_v4 = ngraph::op::v4::Interpolate::NearestMode::floor;
-        auto shape_calculation_mode_v4 = ngraph::op::v4::Interpolate::ShapeCalcMode::sizes;
-        auto coordinate_transformation_mode_v4 = interpolate_attrs.align_corners ? ngraph::op::v4::Interpolate::CoordinateTransformMode::align_corners :
-                                                ngraph::op::v4::Interpolate::CoordinateTransformMode::asymmetric;
-        auto interpolate4_attr = ngraph::op::v4::Interpolate::InterpolateAttrs(mode_v4, shape_calculation_mode_v4,
-            interpolate_attrs.pads_begin, interpolate_attrs.pads_end,
-            coordinate_transformation_mode_v4, nearest_mode_v4, interpolate_attrs.antialias, -0.75);
-
-        // input
-        auto axes = interpolate_attrs.axes.to_vector();
-        auto axes_node = ngraph::opset4::Constant::create(element::i64, {axes.size()}, axes);
-        auto default_scales = std::vector<float>(axes.size(), 1.f);
-        auto scales_node = ngraph::opset4::Constant::create(element::f32, {axes.size()}, default_scales);
+        attrsV4.shape_calculation_mode = ngraph::opset4::Interpolate::ShapeCalcMode::sizes;
+        attrsV4.nearest_mode = ngraph::opset4::Interpolate::NearestMode::round_prefer_floor;
+        attrsV4.pads_begin = attrsV0.pads_begin;
+        attrsV4.pads_end = attrsV0.pads_end;
+        attrsV4.antialias = attrsV0.antialias;
+        attrsV4.coordinate_transformation_mode = ngraph::opset4::Interpolate::CoordinateTransformMode::half_pixel;
+        attrsV4.cube_coeff = -0.75f;
+        if (attrsV0.align_corners) {
+            attrsV4.coordinate_transformation_mode = ngraph::opset4::Interpolate::CoordinateTransformMode::align_corners;
+        }
 
-        auto interpolate4 = std::make_shared<ngraph::opset4::Interpolate>(interpolate1->input_value(0), interpolate1->input_value(1),
-            scales_node, axes_node, interpolate4_attr);
+        auto interpolateV4 = std::make_shared<ngraph::opset4::Interpolate>(interpolationV0->input_value(0), interpolationV0->input_value(1),
+                                                                           scalesConstant, axisConstant, attrsV4);
 
-        interpolate4->set_friendly_name(interpolate1->get_friendly_name());
-        ngraph::copy_runtime_info(interpolate1, interpolate4);
-        ngraph::replace_node(interpolate1, interpolate4);
+        interpolateV4->set_friendly_name(interpolationV0->get_friendly_name());
+        ngraph::copy_runtime_info(interpolationV0, interpolateV4);
+        ngraph::replace_node(interpolationV0, interpolateV4);
         return true;
     };
 

inference-engine/tests/functional/inference_engine/ngraph_reader/interpolate_tests.cpp

@@ -80,18 +80,57 @@ TEST_F(NGraphReaderTests, ReadInterpolateNetwork) {
                 </port>
             </output>
         </layer>
-        <layer id="1" name="interpolate" precision="FP32" type="Interp">
-            <data align_corners="0" pad_beg="0" pad_end="0" mode="linear" width="60" height="50"/>
+        <layer id="1" name="output_shape" precision="I64" type="Const">
+            <output>
+                <port id="0">
+                    <dim>2</dim>
+                </port>
+            </output>
+            <blobs>
+                <custom offset="0" size="16"/>
+            </blobs>
+        </layer>
+        <layer id="2" name="scales" precision="FP32" type="Const">
+            <output>
+                <port id="0">
+                    <dim>2</dim>
+                </port>
+            </output>
+            <blobs>
+                <custom offset="32" size="8"/>
+            </blobs>
+        </layer>
+        <layer id="3" name="axes" precision="I64" type="Const">
+            <output>
+                <port id="0">
+                    <dim>2</dim>
+                </port>
+            </output>
+            <blobs>
+                <custom offset="16" size="16"/>
+            </blobs>
+        </layer>
+        <layer id="4" name="interpolate" precision="FP32" type="Interpolate">
+            <data antialias="False" coordinate_transformation_mode="half_pixel" cube_coeff="-0.75" mode="linear" nearest_mode="round_prefer_floor" pads_begin="0,0,0,0" pads_end="0,0,0,0" shape_calculation_mode="sizes"/>
             <input>
                 <port id="0">
                     <dim>1</dim>
                     <dim>2</dim>
                     <dim>48</dim>
                     <dim>80</dim>
                 </port>
+                <port id="1">
+                    <dim>2</dim>
+                </port>
+                <port id="2">
+                    <dim>2</dim>
+                </port>
+                <port id="3">
+                    <dim>2</dim>
+                </port>
             </input>
             <output>
-                <port id="1">
+                <port id="4" precision="FP32">
                     <dim>1</dim>
                     <dim>2</dim>
                     <dim>50</dim>
@@ -101,16 +140,26 @@ TEST_F(NGraphReaderTests, ReadInterpolateNetwork) {
         </layer>
     </layers>
     <edges>
-        <edge from-layer="0" from-port="0" to-layer="1" to-port="0"/>
+        <edge from-layer="0" from-port="0" to-layer="4" to-port="0"/>
+        <edge from-layer="1" from-port="0" to-layer="4" to-port="1"/>
+        <edge from-layer="2" from-port="0" to-layer="4" to-port="2"/>
+        <edge from-layer="3" from-port="0" to-layer="4" to-port="3"/>
     </edges>
 </net>
 )V0G0N";
-    compareIRs(model, modelV5, 16, [](Blob::Ptr& weights) {
-                auto *data = weights->buffer().as<int64_t *>();
-                data[0] = 50;
-                data[1] = 60;
+    compareIRs(model, modelV5, 40, [](Blob::Ptr& weights) {
+                auto *i64data = weights->buffer().as<int64_t *>();
+                i64data[0] = 50;
+                i64data[1] = 60;
+                i64data[2] = 2;
+                i64data[3] = 3;
+
+                auto *fdata = reinterpret_cast<float *>(i64data + 4);
+                fdata[0] = 50.0 / 48.0;
+                fdata[1] = 60.0 / 80.0;
             });
 }
+
 TEST_F(NGraphReaderTests, ReadInterpolate2Network) {
     std::string model = R"V0G0N(
 <net name="Network" version="10">
@@ -187,18 +236,57 @@ TEST_F(NGraphReaderTests, ReadInterpolate2Network) {
                 </port>
             </output>
         </layer>
-        <layer id="1" name="interpolate" precision="FP32" type="Interp">
-            <data align_corners="0" pad_beg="0" pad_end="0" mode="linear" width="60" height="50"/>
+        <layer id="1" name="output_shape" precision="I64" type="Const">
+            <output>
+                <port id="0">
+                    <dim>4</dim>
+                </port>
+            </output>
+            <blobs>
+                <custom offset="0" size="32"/>
+            </blobs>
+        </layer>
+        <layer id="2" name="scales" precision="FP32" type="Const">
+            <output>
+                <port id="0">
+                    <dim>4</dim>
+                </port>
+            </output>
+            <blobs>
+                <custom offset="64" size="16"/>
+            </blobs>
+        </layer>
+        <layer id="3" name="axes" precision="I64" type="Const">
+            <output>
+                <port id="0">
+                    <dim>4</dim>
+                </port>
+            </output>
+            <blobs>
+                <custom offset="32" size="32"/>
+            </blobs>
+        </layer>
+        <layer id="4" name="interpolate" precision="FP32" type="Interpolate">
+            <data antialias="False" coordinate_transformation_mode="half_pixel" cube_coeff="-0.75" mode="linear" nearest_mode="round_prefer_floor" pads_begin="0,0,0,0" pads_end="0,0,0,0" shape_calculation_mode="sizes"/>
             <input>
                 <port id="0">
                     <dim>1</dim>
                     <dim>2</dim>
                     <dim>48</dim>
                     <dim>80</dim>
                 </port>
+                <port id="1">
+                    <dim>4</dim>
+                </port>
+                <port id="2">
+                    <dim>4</dim>
+                </port>
+                <port id="3">
+                    <dim>4</dim>
+                </port>
             </input>
             <output>
-                <port id="1">
+                <port id="4" precision="FP32">
                     <dim>1</dim>
                     <dim>2</dim>
                     <dim>50</dim>
@@ -208,16 +296,29 @@ TEST_F(NGraphReaderTests, ReadInterpolate2Network) {
         </layer>
     </layers>
     <edges>
-        <edge from-layer="0" from-port="0" to-layer="1" to-port="0"/>
+        <edge from-layer="0" from-port="0" to-layer="4" to-port="0"/>
+        <edge from-layer="1" from-port="0" to-layer="4" to-port="1"/>
+        <edge from-layer="2" from-port="0" to-layer="4" to-port="2"/>
+        <edge from-layer="3" from-port="0" to-layer="4" to-port="3"/>
     </edges>
 </net>
 )V0G0N";
-    compareIRs(model, modelV5, 32, [](Blob::Ptr& weights) {
-                auto *data = weights->buffer().as<int64_t *>();
-                data[0] = 1;
-                data[1] = 2;
-                data[2] = 50;
-                data[3] = 60;
+    compareIRs(model, modelV5, 80, [](Blob::Ptr& weights) {
+                auto *i64data = weights->buffer().as<int64_t *>();
+                i64data[0] = 1;
+                i64data[1] = 2;
+                i64data[2] = 50;
+                i64data[3] = 60;
+                i64data[4] = 0;
+                i64data[5] = 1;
+                i64data[6] = 2;
+                i64data[7] = 3;
+
+                auto *fdata = reinterpret_cast<float *>(i64data + 8);
+                fdata[0] = 1.0;
+                fdata[1] = 1.0;
+                fdata[2] = 50.0 / 48.0;
+                fdata[3] = 60.0 / 80.0;
             });
 }
 
@@ -399,4 +500,4 @@ TEST_F(NGraphReaderTests, ReadInterpolate4Network) {
         fdata[2] = 2.0;
         fdata[3] = 2.0;
     });
-}
+}

inference-engine/tests/functional/inference_engine/transformations/convert_interpolate1_to_interpolate4_test.cpp

@@ -49,7 +49,7 @@ TEST(TransformationTests, ConvertInterpolate1ToInterpolate4) {
     {
         auto data_node = std::make_shared<opset1::Parameter>(element::f32, Shape{2, 4, 30, 30});
         auto out_shape_node = opset1::Constant::create(element::i32, Shape{4}, {2, 4, 40, 40});
-        auto default_scales_node = opset1::Constant::create(ngraph::element::f32, Shape{4}, {1.f, 1.f, 1.f, 1.f});
+        auto default_scales_node = opset1::Constant::create(ngraph::element::f32, Shape{4}, {1.f, 1.f, 4.0f / 3.0f, 4.0f / 3.0f});
         auto axes_node = opset1::Constant::create(ngraph::element::i64, Shape{4}, {0, 1, 2, 3});
 
         auto interpolate4_attr = opset4::Interpolate::InterpolateAttrs(opset4::Interpolate::InterpolateMode::nearest,
@@ -94,10 +94,10 @@ TEST(TransformationTests, ConvertInterpolate1ToInterpolate4_1) {
     {
         auto data_node = std::make_shared<opset1::Parameter>(element::f32, Shape{2, 4, 30, 30});
         auto out_shape_node = opset1::Constant::create(element::i32, Shape{2}, {40, 40});
-        auto default_scales_node = opset1::Constant::create(ngraph::element::f32, Shape{2}, {1.f, 1.f});
+        auto default_scales_node = opset1::Constant::create(ngraph::element::f32, Shape{2}, {4.0f / 3.0f, 4.0f / 3.0f});
         auto axes_node = opset1::Constant::create(ngraph::element::i64, Shape{2}, {2, 3});
 
-        auto interpolate4_attr = opset4::Interpolate::InterpolateAttrs(opset4::Interpolate::InterpolateMode::linear_onnx,
+        auto interpolate4_attr = opset4::Interpolate::InterpolateAttrs(opset4::Interpolate::InterpolateMode::linear,
             opset4::Interpolate::ShapeCalcMode::sizes, std::vector<size_t>{0, 0, 0, 0}, std::vector<size_t>{0, 0, 0, 0},
             opset4::Interpolate::CoordinateTransformMode::align_corners, opset4::Interpolate::NearestMode::floor,
             false, -0.75);

inference-engine/tests/functional/plugin/shared/src/low_precision_transformations/interpolate_transformation.cpp

@@ -85,7 +85,7 @@ void InterpolateTransformation::validate() {
     if (attributes.mode == "nearest") {
         ASSERT_EQ("ScaleShiftIE", typeName);
     } else {
-        ASSERT_EQ("Interp", typeName);
+        ASSERT_TRUE("Interp" == typeName || "Interpolate" == typeName);
     }
 }