zero_dim_tensor_elimination.cpp 10.5 KB
Newer Older
1
//*****************************************************************************
2
// Copyright 2017-2019 Intel Corporation
3 4 5 6 7 8 9 10 11 12 13 14 15
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//*****************************************************************************
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

#include <memory>

#include "gtest/gtest.h"
#include "ngraph/file_util.hpp"
#include "ngraph/graph_util.hpp"
#include "ngraph/log.hpp"
#include "ngraph/ngraph.hpp"
#include "ngraph/op/add.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/divide.hpp"
#include "ngraph/op/multiply.hpp"
#include "ngraph/op/product.hpp"
#include "ngraph/op/sqrt.hpp"
#include "ngraph/op/subtract.hpp"
#include "ngraph/op/sum.hpp"
#include "ngraph/pass/manager.hpp"
#include "ngraph/pass/visualize_tree.hpp"
#include "ngraph/pass/zero_dim_tensor_elimination.hpp"
#include "util/test_tools.hpp"

using namespace ngraph;
using namespace std;

TEST(zero_dim_tensor_elimination, zero_sum)
{
    Shape zero_shape{0};
    auto A = std::make_shared<op::Parameter>(element::i32, zero_shape);
    auto abs_node = std::make_shared<op::Abs>(A);
    auto sum_node = std::make_shared<op::Sum>(abs_node, AxisSet{0});
    auto constant = std::make_shared<op::Constant>(element::i32, zero_shape, std::vector<string>{});
47
    auto f = std::make_shared<Function>(NodeVector{sum_node, constant}, ParameterVector{A});
48 49
    pass::Manager pass_manager;

50
    pass_manager.register_pass<pass::VisualizeTree>("zero_sum_before.png");
51
    pass_manager.register_pass<ngraph::pass::ZeroDimTensorElimination>();
52 53
    pass_manager.register_pass<pass::VisualizeTree>("zero_sum_after.png");
    EXPECT_EQ(count_ops_of_type<op::Sum>(f), 1);
54
    pass_manager.run_passes(f);
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
    EXPECT_EQ(count_ops_of_type<op::Sum>(f), 0);
}

TEST(zero_dim_tensor_elimination, zero_product)
{
    Shape zero_shape{0};
    auto A = std::make_shared<op::Parameter>(element::i32, zero_shape);
    auto abs_node = std::make_shared<op::Abs>(A);
    auto product_node = std::make_shared<op::Product>(abs_node, AxisSet{0});
    auto constant = std::make_shared<op::Constant>(element::i32, zero_shape, std::vector<string>{});
    auto f = std::make_shared<Function>(NodeVector{product_node, constant}, ParameterVector{A});
    pass::Manager pass_manager;

    pass_manager.register_pass<pass::VisualizeTree>("zero_product_before.png");
    pass_manager.register_pass<ngraph::pass::ZeroDimTensorElimination>();
    pass_manager.register_pass<pass::VisualizeTree>("zero_product_after.png");
    EXPECT_EQ(count_ops_of_type<op::Product>(f), 1);
    pass_manager.run_passes(f);
    EXPECT_EQ(count_ops_of_type<op::Product>(f), 0);
}

TEST(zero_dim_tensor_elimination, zero_min)
{
    Shape zero_shape{0};
    auto A = std::make_shared<op::Parameter>(element::i32, zero_shape);
    auto abs_node = std::make_shared<op::Abs>(A);
    auto min_node = std::make_shared<op::Min>(abs_node, AxisSet{0});
    auto constant = std::make_shared<op::Constant>(element::i32, zero_shape, std::vector<string>{});
    auto f = std::make_shared<Function>(NodeVector{min_node, constant}, ParameterVector{A});
    pass::Manager pass_manager;

    pass_manager.register_pass<pass::VisualizeTree>("zero_min_before.png");
    pass_manager.register_pass<ngraph::pass::ZeroDimTensorElimination>();
    pass_manager.register_pass<pass::VisualizeTree>("zero_min_after.png");
    EXPECT_EQ(count_ops_of_type<op::Min>(f), 1);
    pass_manager.run_passes(f);
    EXPECT_EQ(count_ops_of_type<op::Min>(f), 0);
}

TEST(zero_dim_tensor_elimination, zero_max)
{
    Shape zero_shape{0};
    auto A = std::make_shared<op::Parameter>(element::i32, zero_shape);
    auto abs_node = std::make_shared<op::Abs>(A);
    auto max_node = std::make_shared<op::Max>(abs_node, AxisSet{0});
    auto constant = std::make_shared<op::Constant>(element::i32, zero_shape, std::vector<string>{});
    auto f = std::make_shared<Function>(NodeVector{max_node, constant}, ParameterVector{A});
    pass::Manager pass_manager;

    pass_manager.register_pass<pass::VisualizeTree>("zero_max_before.png");
    pass_manager.register_pass<ngraph::pass::ZeroDimTensorElimination>();
    pass_manager.register_pass<pass::VisualizeTree>("zero_max_after.png");
    EXPECT_EQ(count_ops_of_type<op::Max>(f), 1);
    pass_manager.run_passes(f);
    EXPECT_EQ(count_ops_of_type<op::Max>(f), 0);
110 111 112 113 114 115 116 117 118 119 120 121
}

TEST(zero_dim_tensor_elimination, zero_const_conv)
{
    Shape zero_shape{0};
    auto A = std::make_shared<op::Parameter>(element::f32, Shape{1, 1, 0});
    auto weights = std::make_shared<op::Parameter>(element::f32, Shape{1, 1, 4});
    auto convolution = std::make_shared<op::Convolution>(
        A, weights, Strides{1}, Strides{1}, CoordinateDiff{2}, CoordinateDiff{2});
    auto abs_node = std::make_shared<op::Abs>(convolution);
    auto constant = std::make_shared<op::Constant>(element::i32, zero_shape, std::vector<string>{});
    auto f =
122
        std::make_shared<Function>(NodeVector{abs_node, constant}, ParameterVector{A, weights});
123 124
    pass::Manager pass_manager;

125
    pass_manager.register_pass<pass::VisualizeTree>("zero_const_conv_before.png");
126
    pass_manager.register_pass<ngraph::pass::ZeroDimTensorElimination>();
127 128
    pass_manager.register_pass<pass::VisualizeTree>("zero_const_conv_after.png");
    EXPECT_EQ(count_ops_of_type<op::Convolution>(f), 1);
129
    pass_manager.run_passes(f);
130
    EXPECT_EQ(count_ops_of_type<op::Convolution>(f), 0);
131 132 133 134 135 136 137 138 139 140 141
}

TEST(zero_dim_tensor_elimination, zero_const_avg_pool)
{
    Shape zero_shape{0};
    auto A = std::make_shared<op::Parameter>(element::f32, Shape{1, 1, 0});

    auto avg_pool =
        std::make_shared<op::AvgPool>(A, Shape{1}, Strides{1}, Shape{2}, Shape{2}, true);
    auto abs_node = std::make_shared<op::Abs>(avg_pool);
    auto constant = std::make_shared<op::Constant>(element::i32, zero_shape, std::vector<string>{});
142
    auto f = std::make_shared<Function>(NodeVector{abs_node, constant}, ParameterVector{A});
143 144
    pass::Manager pass_manager;

145
    pass_manager.register_pass<pass::VisualizeTree>("zero_const_avg_pool_before.png");
146
    pass_manager.register_pass<ngraph::pass::ZeroDimTensorElimination>();
147 148
    pass_manager.register_pass<pass::VisualizeTree>("zero_const_avg_pool_after.png");
    EXPECT_EQ(count_ops_of_type<op::AvgPool>(f), 1);
149
    pass_manager.run_passes(f);
150
    EXPECT_EQ(count_ops_of_type<op::AvgPool>(f), 0);
151 152 153 154 155 156 157 158
}

TEST(zero_dim_tensor_elimination, zero_const_pad)
{
    Shape zero_shape{0};
    auto A = std::make_shared<op::Parameter>(element::f32, zero_shape);
    auto B = std::make_shared<op::Parameter>(element::f32, Shape{});

159
    auto pad = std::make_shared<op::Pad>(A, B, CoordinateDiff{2}, CoordinateDiff{2});
160 161
    auto abs_node = std::make_shared<op::Abs>(pad);
    auto constant = std::make_shared<op::Constant>(element::i32, zero_shape, std::vector<string>{});
162
    auto f = std::make_shared<Function>(NodeVector{abs_node, constant}, ParameterVector{A, B});
163 164
    pass::Manager pass_manager;

165
    pass_manager.register_pass<pass::VisualizeTree>("zero_const_pad_before.png");
166
    pass_manager.register_pass<ngraph::pass::ZeroDimTensorElimination>();
167 168
    pass_manager.register_pass<pass::VisualizeTree>("zero_const_pad_after.png");
    EXPECT_EQ(count_ops_of_type<op::Broadcast>(f), 0);
169
    pass_manager.run_passes(f);
170
    EXPECT_EQ(count_ops_of_type<op::Broadcast>(f), 1);
171 172 173 174 175 176 177 178
}

TEST(zero_dim_tensor_elimination, zero_const_slice)
{
    Shape zero_shape{0};
    auto A = std::make_shared<op::Parameter>(element::f32, zero_shape);
    auto B = std::make_shared<op::Parameter>(element::f32, Shape{});
    auto slice = make_shared<op::Slice>(A, Coordinate{0}, Coordinate{0});
179
    auto pad = std::make_shared<op::Pad>(A, B, CoordinateDiff{2}, CoordinateDiff{2});
180 181
    auto abs_node = std::make_shared<op::Abs>(pad);
    auto constant = std::make_shared<op::Constant>(element::i32, zero_shape, std::vector<string>{});
182
    auto f = std::make_shared<Function>(NodeVector{abs_node, constant}, ParameterVector{A, B});
183 184
    pass::Manager pass_manager;

185
    pass_manager.register_pass<pass::VisualizeTree>("zero_const_slice_before.png");
186
    pass_manager.register_pass<ngraph::pass::ZeroDimTensorElimination>();
187 188 189
    pass_manager.register_pass<pass::VisualizeTree>("zero_const_slice_after.png");
    EXPECT_EQ(count_ops_of_type<op::Broadcast>(f), 0);
    EXPECT_EQ(count_ops_of_type<op::Slice>(f), 0);
190
    pass_manager.run_passes(f);
191 192
    EXPECT_EQ(count_ops_of_type<op::Broadcast>(f), 1);
    EXPECT_EQ(count_ops_of_type<op::Slice>(f), 0);
193
}
194

195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
TEST(zero_dim_tensor_elimination, zero_argmax)
{
    auto A = std::make_shared<op::Parameter>(element::f32, Shape{0, 2, 3});
    auto argmax = make_shared<op::ArgMax>(A, 1, element::i32);
    auto f = std::make_shared<Function>(NodeVector{argmax}, ParameterVector{A});
    pass::Manager pass_manager;

    pass_manager.register_pass<pass::VisualizeTree>("zero_argmax_before.png");
    pass_manager.register_pass<ngraph::pass::ZeroDimTensorElimination>();
    pass_manager.register_pass<pass::VisualizeTree>("zero_argmax_after.png");
    EXPECT_EQ(count_ops_of_type<op::ArgMax>(f), 1);
    pass_manager.run_passes(f);
    EXPECT_EQ(count_ops_of_type<op::ArgMax>(f), 0);
    EXPECT_EQ(f->get_results().at(0)->get_shape(), (Shape{0, 3}));
}

TEST(zero_dim_tensor_elimination, zero_argmin)
{
    auto A = std::make_shared<op::Parameter>(element::f32, Shape{0, 2, 3});
    auto argmin = make_shared<op::ArgMin>(A, 1, element::i32);
    auto f = std::make_shared<Function>(NodeVector{argmin}, ParameterVector{A});
    pass::Manager pass_manager;

    pass_manager.register_pass<pass::VisualizeTree>("zero_argmin_before.png");
    pass_manager.register_pass<ngraph::pass::ZeroDimTensorElimination>();
    pass_manager.register_pass<pass::VisualizeTree>("zero_argmin_after.png");
    EXPECT_EQ(count_ops_of_type<op::ArgMin>(f), 1);
    pass_manager.run_passes(f);
    EXPECT_EQ(count_ops_of_type<op::ArgMin>(f), 0);
    EXPECT_EQ(f->get_results().at(0)->get_shape(), (Shape{0, 3}));
}

227 228 229 230 231 232
TEST(zero_dim_tensor_elimination, pass_property)
{
    auto pass = std::make_shared<ngraph::pass::ZeroDimTensorElimination>();
    ASSERT_EQ(true, pass->get_property(pass::PassProperty::REQUIRE_STATIC_SHAPE));
    ASSERT_EQ(false, pass->get_property(pass::PassProperty::CHANGE_DYNAMIC_STATE));
}