1 //*****************************************************************************
2 // Copyright 2017-2020 Intel Corporation
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
8 // http://www.apache.org/licenses/LICENSE-2.0
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //*****************************************************************************
16 #include "opset1_upgrade.hpp"
23 #include "ngraph/builder/autobroadcast.hpp"
24 #include "ngraph/builder/reshape.hpp"
25 #include "ngraph/graph_util.hpp"
26 #include "ngraph/op/util/op_types.hpp"
27 #include "ngraph/ops.hpp"
28 #include "ngraph/provenance.hpp"
29 #include "op/avg_pool.hpp"
30 #include "op/convolution.hpp"
31 #include "op/group_conv.hpp"
33 NGRAPH_SUPPRESS_DEPRECATED_START
36 using namespace ngraph;
38 namespace opset1_upgrade
40 template <typename OpV0, typename OpV1>
41 shared_ptr<Node> op_cast_binary_elementwise_node(const shared_ptr<OpV0>& node)
43 const auto autob = node->get_autob();
44 auto replacement_node =
45 make_shared<OpV1>(node->input_value(0), node->input_value(1), autob);
46 replace_node(node, replacement_node);
47 return replacement_node;
50 // Default is that we didn nothing
51 shared_ptr<Node> op_cast(shared_ptr<Node> node) { return nullptr; }
52 shared_ptr<Node> op_cast(shared_ptr<op::Add> node)
54 return op_cast_binary_elementwise_node<op::v0::Add, op::v1::Add>(node);
57 shared_ptr<Node> op_cast(shared_ptr<op::Broadcast> node)
59 auto replacement_node = ngraph::builder::opset1::make_broadcast(
60 node->input_value(0), node->get_broadcast_shape(), node->get_broadcast_axes());
61 replace_node(node, replacement_node.get_node_shared_ptr());
62 return replacement_node.get_node_shared_ptr();
65 shared_ptr<Node> op_cast(shared_ptr<op::BroadcastLike> node) { return nullptr; }
66 shared_ptr<Node> op_cast(shared_ptr<op::v0::Convolution> node)
68 auto strides = node->get_window_movement_strides();
69 auto dilations = node->get_window_dilation_strides();
70 auto pads_begin = node->get_padding_below();
71 auto pads_end = node->get_padding_above();
72 auto data_dilation_strides = node->get_data_dilation_strides();
73 auto auto_pad = node->get_pad_type();
75 bool is_dds_valid = all_of(data_dilation_strides.begin(),
76 data_dilation_strides.end(),
77 [](size_t value) { return value == 1; });
79 NGRAPH_CHECK(is_dds_valid,
80 "Unable to convert Convolution:0 to Convolution:1 with data dilation strides "
81 "other than `1`. Node: ",
84 auto replacement_node = make_shared<op::v1::Convolution>(node->input_value(0),
91 replace_node(node, replacement_node);
92 return replacement_node;
95 shared_ptr<Node> op_cast(shared_ptr<op::v0::ConvolutionBackpropData> node)
97 auto data_batch_shape = node->get_data_batch_shape();
98 auto strides = node->get_window_movement_strides_forward();
99 auto dilations = node->get_window_dilation_strides_forward();
100 auto pads_begin = node->get_padding_below_forward();
101 auto pads_end = node->get_padding_above_forward();
102 auto data_dilation_strides = node->get_data_dilation_strides_forward();
104 bool is_dds_valid = all_of(data_dilation_strides.begin(),
105 data_dilation_strides.end(),
106 [](size_t value) { return value == 1; });
108 NGRAPH_CHECK(is_dds_valid,
109 "Unable to convert ConvolutionBackpropData:0 to ConvolutionBackpropData:1 "
110 "with data dilation strides "
111 "other than `1`. Node: ",
114 auto replacement_node = make_shared<op::v1::ConvolutionBackpropData>(
115 node->input_value(1), // data
116 node->input_value(0), // filters
117 op::Constant::create(
119 Shape{data_batch_shape.size() - 2},
120 vector<size_t>(data_batch_shape.begin() + 2, data_batch_shape.end())),
125 replace_node(node, replacement_node);
126 return replacement_node;
129 shared_ptr<Node> op_cast(shared_ptr<op::Divide> node)
131 const auto autob = node->get_autob();
132 const bool pydiv = node->is_pythondiv();
133 auto replacement_node =
134 make_shared<op::v1::Divide>(node->input_value(0), node->input_value(1), pydiv, autob);
135 replace_node(node, replacement_node);
136 return replacement_node;
139 shared_ptr<Node> op_cast(shared_ptr<op::Reshape> node)
141 shared_ptr<Node> replacement_node =
142 builder::opset1::reshape(node->input_value(0), node->get_reshape_output_shape());
143 replace_node(node, replacement_node);
144 return replacement_node;
147 shared_ptr<Node> op_cast(shared_ptr<op::Equal> node)
149 return op_cast_binary_elementwise_node<op::v0::Equal, op::v1::Equal>(node);
152 shared_ptr<Node> op_cast(shared_ptr<op::Gather> node)
154 int64_t axis = node->get_axis();
156 auto axis_node = make_shared<op::Constant>(element::i64, Shape{}, vector<int64_t>{axis});
157 auto replacement_node =
158 make_shared<op::v1::Gather>(node->input_value(0), node->input_value(1), axis_node);
159 replace_node(node, replacement_node);
160 return replacement_node;
163 shared_ptr<Node> op_cast(shared_ptr<op::Greater> node)
165 return op_cast_binary_elementwise_node<op::v0::Greater, op::v1::Greater>(node);
168 shared_ptr<Node> op_cast(shared_ptr<op::GreaterEq> node)
170 return op_cast_binary_elementwise_node<op::v0::GreaterEq, op::v1::GreaterEqual>(node);
173 shared_ptr<Node> op_cast(shared_ptr<op::v0::GroupConvolution> node)
175 auto strides = node->get_window_movement_strides();
176 auto dilations = node->get_window_dilation_strides();
177 auto pads_begin = node->get_padding_below();
178 auto pads_end = node->get_padding_above();
179 auto data_dilation_strides = node->get_data_dilation_strides();
180 auto auto_pad = node->get_pad_type();
182 bool is_dds_valid = all_of(data_dilation_strides.begin(),
183 data_dilation_strides.end(),
184 [](size_t value) { return value == 1; });
186 NGRAPH_CHECK(is_dds_valid,
187 "Unable to convert GroupConvolution:0 to GroupConvolution:1"
188 "with data dilation strides other than `1`. Node: ",
191 shared_ptr<Node> replacement_node;
192 if (node->has_groups_in_filters())
194 replacement_node = make_shared<op::v1::GroupConvolution>(node->input_value(0),
195 node->input_value(1),
204 NGRAPH_CHECK(node->get_input_partial_shape(1).is_static(),
205 "Unable to convert GroupConvolution:0 to GroupConvolution:1"
206 "with dynamic filters shape. Node: ",
209 auto filters_shape = node->get_input_shape(1);
210 auto groups = node->get_groups();
211 filters_shape[0] /= groups;
212 filters_shape.insert(filters_shape.begin(), groups);
214 auto reshaped_filters = builder::opset1::reshape(node->input_value(1), filters_shape);
216 replacement_node = make_shared<op::v1::GroupConvolution>(node->input_value(0),
224 replace_node(node, replacement_node);
225 return replacement_node;
228 shared_ptr<Node> op_cast(shared_ptr<op::v0::GroupConvolutionBackpropData> node)
230 const auto strides = node->get_window_movement_strides();
231 const auto dilations = node->get_window_dilation_strides();
232 const auto pads_begin = node->get_padding_below();
233 const auto pads_end = node->get_padding_above();
235 const auto data_batch_pshape = node->get_input_partial_shape(0);
236 const auto filters_pshape = node->get_input_partial_shape(1);
238 NGRAPH_CHECK(data_batch_pshape.is_static(),
239 "Unable to convert GroupConvolutionBackpropData:0 to "
240 "GroupConvolutionBackpropData:1 with dynamic data_batch shape. Node: ",
242 NGRAPH_CHECK(filters_pshape.is_static(),
243 "Unable to convert GroupConvolutionBackpropData:0 to "
244 "GroupConvolutionBackpropData:1 with dynamic filters shape. Node: ",
247 auto data_batch_shape = data_batch_pshape.to_shape();
248 // Remove N, C from output shape to preserve only spatial dimentions.
249 data_batch_shape.erase(std::begin(data_batch_shape),
250 std::next(std::begin(data_batch_shape), 2));
251 auto filters_shape = filters_pshape.to_shape();
252 auto groups = node->get_groups();
254 filters_shape[0] /= groups;
255 filters_shape.insert(filters_shape.begin(), groups);
256 auto reshaped_filters = builder::opset1::reshape(node->input_value(1), filters_shape);
258 auto replacement_node = make_shared<op::v1::GroupConvolutionBackpropData>(
259 node->input_value(2),
261 op::Constant::create(element::i64, Shape{data_batch_shape.size()}, data_batch_shape),
266 replace_node(node, replacement_node);
267 return replacement_node;
270 shared_ptr<Node> op_cast(shared_ptr<op::Less> node)
272 return op_cast_binary_elementwise_node<op::v0::Less, op::v1::Less>(node);
275 shared_ptr<Node> op_cast(shared_ptr<op::LessEq> node)
277 return op_cast_binary_elementwise_node<op::v0::LessEq, op::v1::LessEqual>(node);
280 shared_ptr<Node> op_cast(shared_ptr<op::Max> node)
282 bool keep_dims = false;
283 auto replacement_node =
284 make_shared<op::v1::ReduceMax>(node->input_value(0), node->input_value(1), keep_dims);
285 replace_node(node, replacement_node);
286 return replacement_node;
289 shared_ptr<Node> op_cast(shared_ptr<op::Maximum> node)
291 return op_cast_binary_elementwise_node<op::v0::Maximum, op::v1::Maximum>(node);
294 shared_ptr<Node> op_cast(shared_ptr<op::Min> node)
296 bool keep_dims = false;
297 auto replacement_node =
298 make_shared<op::v1::ReduceMin>(node->input_value(0), node->input_value(1), keep_dims);
299 replace_node(node, replacement_node);
300 return replacement_node;
303 shared_ptr<Node> op_cast(shared_ptr<op::Minimum> node)
305 return op_cast_binary_elementwise_node<op::v0::Minimum, op::v1::Minimum>(node);
308 shared_ptr<Node> op_cast(shared_ptr<op::Multiply> node)
310 return op_cast_binary_elementwise_node<op::v0::Multiply, op::v1::Multiply>(node);
313 shared_ptr<Node> op_cast(shared_ptr<op::Not> node)
315 auto replacement_node = make_shared<op::v1::LogicalNot>(node->input_value(0));
316 replace_node(node, replacement_node);
317 return replacement_node;
320 shared_ptr<Node> op_cast(shared_ptr<op::NotEqual> node)
322 return op_cast_binary_elementwise_node<op::v0::NotEqual, op::v1::NotEqual>(node);
325 shared_ptr<Node> op_cast(shared_ptr<op::OneHot> node)
327 const auto indices = node->input_value(0).get_node_shared_ptr();
328 const auto one_hot_axis = node->get_one_hot_axis();
330 const auto output_pshape = node->get_output_partial_shape(0);
331 NGRAPH_CHECK(output_pshape[one_hot_axis].is_static(),
332 "OneHot:v0 one hot axis dimension must be static ",
334 const auto depth = output_pshape[one_hot_axis].get_length();
335 const auto depth_node = op::Constant::create(element::i64, Shape{}, {depth});
337 const auto on_value = op::Constant::create(element::i64, Shape{}, {1});
338 const auto off_value = op::Constant::create(element::i64, Shape{}, {0});
340 auto replacement_node =
341 make_shared<op::v1::OneHot>(indices, depth_node, on_value, off_value, one_hot_axis);
342 replace_node(node, replacement_node);
343 return replacement_node;
346 shared_ptr<Node> op_cast(shared_ptr<op::Or> node)
348 return op_cast_binary_elementwise_node<op::v0::Or, op::v1::LogicalOr>(node);
351 shared_ptr<Node> op_cast(shared_ptr<op::Power> node)
353 return op_cast_binary_elementwise_node<op::v0::Power, op::v1::Power>(node);
356 shared_ptr<Node> op_cast(shared_ptr<op::Product> node)
358 bool keep_dims = false;
359 auto replacement_node =
360 make_shared<op::v1::ReduceProd>(node->input_value(0), node->input_value(1), keep_dims);
361 replace_node(node, replacement_node);
362 return replacement_node;
365 shared_ptr<Node> op_cast(shared_ptr<op::Reverse> node)
367 // creates a Constant node from the v0::Reverse reversed_axes attribute
368 // and uses it as the second input of v1::Reverse
369 const auto reversed_axes = node->get_reversed_axes();
371 const auto reversed_axes_constant = op::Constant::create(
372 element::i64, Shape{reversed_axes.size()}, reversed_axes.to_vector());
374 const auto replacement_node = make_shared<op::v1::Reverse>(
375 node->input_value(0), reversed_axes_constant, op::v1::Reverse::Mode::INDEX);
377 replace_node(node, replacement_node);
378 return replacement_node;
381 shared_ptr<Node> op_cast(shared_ptr<op::Select> node)
383 auto replacement_node = make_shared<op::v1::Select>(node->input_value(0),
384 node->input_value(1),
385 node->input_value(2),
386 op::AutoBroadcastSpec());
387 replace_node(node, replacement_node);
388 return replacement_node;
391 shared_ptr<Node> op_cast(shared_ptr<op::Softmax> node)
393 NGRAPH_CHECK(op::is_constant(node->input_value(1).get_node()),
394 "axes parameter is expected to be a static constant");
396 AxisSet axes = node->get_axes();
400 "Unable to convert Softmax:0 to Softmax:1 with zero or more than one axis. Node: ",
403 auto replacement_node =
404 make_shared<op::v1::Softmax>(node->input_value(0), axes.to_vector()[0]);
405 replace_node(node, replacement_node);
406 return replacement_node;
409 shared_ptr<Node> op_cast(shared_ptr<op::Slice> node)
411 const auto data = node->input_value(0);
412 const auto begin = op::Constant::create(
413 element::i64, Shape{node->get_lower_bounds().size()}, node->get_lower_bounds());
414 const auto end = op::Constant::create(
415 element::i64, Shape{node->get_upper_bounds().size()}, node->get_upper_bounds());
416 const auto strides = op::Constant::create(
417 element::i64, Shape{node->get_strides().size()}, node->get_strides());
418 int64_t input_size = node->get_lower_bounds().size();
420 auto replacement_node = make_shared<op::v1::StridedSlice>(data,
424 vector<int64_t>(input_size, 0),
425 vector<int64_t>(input_size, 0));
427 replace_node(node, replacement_node);
428 return replacement_node;
431 shared_ptr<Node> op_cast(shared_ptr<op::Split> node)
433 const auto& splits_vec = node->get_splits();
434 const auto first_elem = splits_vec.front();
436 const bool split_evenly =
437 std::all_of(splits_vec.begin(), splits_vec.end(), [first_elem](const size_t split) {
438 return split == first_elem;
441 std::shared_ptr<Node> replacement_node;
444 replacement_node = make_shared<op::v1::Split>(
445 node->input_value(0), node->input_value(1), splits_vec.front());
449 const auto split_lengths =
450 ngraph::op::Constant::create(element::u64, Shape{splits_vec.size()}, splits_vec);
452 replacement_node = make_shared<op::v1::VariadicSplit>(
453 node->input_value(0), node->input_value(1), split_lengths);
456 replace_node(node, replacement_node);
457 return replacement_node;
460 shared_ptr<Node> op_cast(shared_ptr<op::Subtract> node)
462 return op_cast_binary_elementwise_node<op::v0::Subtract, op::v1::Subtract>(node);
465 shared_ptr<Node> op_cast(shared_ptr<op::Sum> node)
467 bool keep_dims = false;
468 auto replacement_node =
469 make_shared<op::v1::ReduceSum>(node->input_value(0), node->input_value(1), keep_dims);
470 replace_node(node, replacement_node);
471 return replacement_node;
474 shared_ptr<Node> op_cast(shared_ptr<op::TopK> node)
476 NGRAPH_CHECK(op::is_constant(node->input_value(1).get_node()),
477 "parameter k is expected to be a static constant");
478 NGRAPH_CHECK(op::is_constant(node->input_value(2).get_node()),
479 "parameter top_k_axis is expected to be a static constant");
481 const auto k = node->get_k();
482 const auto axis = node->get_top_k_axis();
485 switch (node->get_sort())
487 case op::TopK::SortType::SORT_INDICES: sort = "index"; break;
488 case op::TopK::SortType::SORT_VALUES: sort = "value"; break;
489 case op::TopK::SortType::NONE: sort = "none"; break;
493 if (node->get_compute_max())
502 const auto k_constant = op::Constant::create(element::i64, Shape{}, {k});
503 auto replacement_node =
504 make_shared<op::v1::TopK>(node->input_value(0), k_constant, axis, mode, sort);
506 // indices output will be 0, values 1
507 vector<int64_t> output_order{1, 0};
508 replace_node(node, replacement_node, output_order);
509 return replacement_node;
512 shared_ptr<Node> op_cast(shared_ptr<op::Xor> node)
514 auto replacement_node = make_shared<op::v1::LogicalXor>(
515 node->input_value(0), node->input_value(1), node->get_autob());
516 replace_node(node, replacement_node);
517 return replacement_node;
520 using DispatchMap = map<NodeTypeInfo, std::function<bool(shared_ptr<Node> node)>>;
522 template <typename T>
523 bool op_cast_thunk(shared_ptr<Node> node)
525 auto upgraded_node = op_cast(as_type_ptr<T>(node));
528 if (ngraph::get_provenance_enabled())
530 const std::string provenance_tag =
531 "<Opset1_Upgrade (v0 " + std::string(node->get_type_name()) + ")>";
532 upgraded_node->add_provenance_tags_above(node->input_values(), {provenance_tag});
539 DispatchMap& get_dispatch_map()
541 NGRAPH_SUPPRESS_DEPRECATED_START
542 static DispatchMap dispatch_map{
543 #define NGRAPH_OP(NAME, NAMESPACE) {NAMESPACE::NAME::type_info, op_cast_thunk<NAMESPACE::NAME>},
544 #include "opset0_tbl.hpp"
548 NGRAPH_SUPPRESS_DEPRECATED_END
550 } // namespace opset1_upgrade
552 bool pass::Opset1Upgrade::run_on_node(shared_ptr<Node> node)
554 bool modified = false;
555 auto& dispatch_map = opset1_upgrade::get_dispatch_map();
556 auto it = dispatch_map.find(node->get_type_info());
557 if (it != dispatch_map.end())
559 modified = it->second(node);