Add op impl check tests (#10339)
* Remove fp16 of Convert layer test from skip_tests.config.cpp as it works now * update repo * add initial op impl check tests * add op imple check tests * add op impl check tests * add rnn cell based ops * modify lstmsequence * update rnn cell base op test * add priorbox, priorboxclustered, proposal * add ROIAlign to ReverseSequence * add Roll to ScatterElementsUpdate * add select to swish tests * add tensoriterator to variadicsplit test * temporary block of LSTMCell v1 due to crash in mkldnn * use ov namespace instead of ngraph as possible * update indexing of vector array * update multiple parameter vector * add loop test * fix cpplint errors * fix build error
This commit is contained in:
Wilson Seok
GitHub
parent
86b175534a
commit
969060c8db
@ -536,6 +536,397 @@ std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Parameter>
|
||||
return std::make_shared<ov::Model>(in, ParameterVector{in}, "Parameter-1");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::PriorBox> &node) {
|
||||
ov::op::v0::PriorBox::Attributes attrs;
|
||||
attrs.min_size = {2.0f};
|
||||
attrs.aspect_ratio = {1.5f};
|
||||
attrs.scale_all_sizes = false;
|
||||
const auto LS = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2}, {2, 2});
|
||||
const auto IS = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2}, {10, 10});
|
||||
auto Node = std::make_shared<ov::op::v0::PriorBox>(LS, IS, attrs);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, ov::ParameterVector{}, "PrioBoxGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v8::PriorBox> &node) {
|
||||
ov::op::v8::PriorBox::Attributes attrs;
|
||||
attrs.min_size = {2.0f};
|
||||
attrs.max_size = {5.0f};
|
||||
attrs.aspect_ratio = {1.5f};
|
||||
attrs.scale_all_sizes = true;
|
||||
attrs.min_max_aspect_ratios_order = false;
|
||||
const auto LS = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2}, {2, 2});
|
||||
const auto IS = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2}, {10, 10});
|
||||
auto Node = std::make_shared<ov::op::v8::PriorBox>(LS, IS, attrs);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, ov::ParameterVector{}, "PrioBoxGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::PriorBoxClustered> &node) {
|
||||
ov::op::v0::PriorBoxClustered::Attributes attrs;
|
||||
attrs.widths = {3.0f};
|
||||
attrs.heights = {3.0f};
|
||||
attrs.clip = true;
|
||||
const auto LS = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2}, {2, 2});
|
||||
const auto IS = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2}, {10, 10});
|
||||
auto Node = std::make_shared<ov::op::v0::PriorBoxClustered>(LS, IS, attrs);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, ov::ParameterVector{}, "PrioBoxClustedGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Proposal> &node) {
|
||||
ov::op::v0::Proposal::Attributes attrs;
|
||||
attrs.base_size = 16;
|
||||
attrs.min_size = 16;
|
||||
attrs.pre_nms_topn = 6000;
|
||||
attrs.post_nms_topn = 10;
|
||||
attrs.nms_thresh = 0.7f;
|
||||
attrs.feat_stride = 16;
|
||||
attrs.min_size = 16;
|
||||
attrs.ratio = {0.5f};
|
||||
attrs.scale = {32.0f};
|
||||
attrs.clip_before_nms = true;
|
||||
attrs.clip_after_nms = false;
|
||||
attrs.normalize = false;
|
||||
attrs.box_size_scale = 1.0f;
|
||||
attrs.box_coordinate_scale = 1.0f;
|
||||
attrs.framework = "";
|
||||
attrs.infer_probs = false;
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 2, 10, 10},
|
||||
{1, 4, 10, 10},
|
||||
{3}});
|
||||
auto Node = std::make_shared<ov::op::v0::Proposal>(params.at(0), params.at(1), params.at(2), attrs);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "ProposalGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v4::Proposal> &node) {
|
||||
ov::op::v4::Proposal::Attributes attrs;
|
||||
attrs.base_size = 16;
|
||||
attrs.min_size = 16;
|
||||
attrs.pre_nms_topn = 6000;
|
||||
attrs.post_nms_topn = 10;
|
||||
attrs.nms_thresh = 0.7f;
|
||||
attrs.feat_stride = 16;
|
||||
attrs.min_size = 16;
|
||||
attrs.ratio = {0.5f};
|
||||
attrs.scale = {32.0f};
|
||||
attrs.clip_before_nms = true;
|
||||
attrs.clip_after_nms = false;
|
||||
attrs.normalize = false;
|
||||
attrs.box_size_scale = 1.0f;
|
||||
attrs.box_coordinate_scale = 1.0f;
|
||||
attrs.framework = "";
|
||||
attrs.infer_probs = true;
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 2, 10, 10},
|
||||
{1, 4, 10, 10},
|
||||
{3}});
|
||||
auto Node = std::make_shared<ov::op::v4::Proposal>(params.at(0), params.at(1), params.at(2), attrs);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "ProposalGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v3::ROIAlign> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 1, 16, 16}});
|
||||
const auto coords = ngraph::builder::makeConstant<float>(ov::element::f32, {2, 4}, {2, 2, 8, 8, 2, 2, 8, 8});
|
||||
const auto roisIdx = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2}, {0, 1});
|
||||
auto Node = std::make_shared<ov::op::v3::ROIAlign>(params.at(0), coords, roisIdx, 2, 2, 2, 1, "avg");
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "ROIAlignGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::ROIPooling> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 3, 8, 8},
|
||||
{1, 5}});
|
||||
auto Node = std::make_shared<ov::op::v0::ROIPooling>(params.at(0), params.at(1), Shape{1, 1}, 1);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "ROIPoolingGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v8::RandomUniform> &node) {
|
||||
const auto out_shape_ = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {4}, {1, 3, 3, 3});
|
||||
const auto min_value = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {0.f});
|
||||
const auto max_value = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {1.f});
|
||||
auto Node = std::make_shared<ov::op::v8::RandomUniform>(out_shape_, min_value, max_value, ov::element::f32, 10, 10);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, ov::ParameterVector{}, "RandomUniformGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Range> &node) {
|
||||
const auto start = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {1.f});
|
||||
const auto stop = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {5.f});
|
||||
const auto step = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {1.f});
|
||||
auto Node = std::make_shared<ov::op::v0::Range>(start, stop, step);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, ov::ParameterVector{}, "RangeGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v4::Range> &node) {
|
||||
const auto start = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {1.f});
|
||||
const auto stop = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {5.f});
|
||||
const auto step = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {1.f});
|
||||
auto Node = std::make_shared<ov::op::v4::Range>(start, stop, step, ov::element::f32);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, ov::ParameterVector{}, "RangeGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::RegionYolo> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 8, 2, 2}});
|
||||
auto Node = std::make_shared<ov::op::v0::RegionYolo>(params.at(0), 4, 1, 1, true, std::vector<int64_t>{0}, 1, 3);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "RegionYoloGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::ReorgYolo> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 8, 4, 4}});
|
||||
auto Node = std::make_shared<ov::op::v0::ReorgYolo>(params.at(0), ov::Strides{2});
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "ReorgYoloGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::Reshape> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 2, 3}});
|
||||
const auto shape = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {1}, {12});
|
||||
auto Node = std::make_shared<ov::op::v1::Reshape>(params.at(0), shape, false);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "ReshapeGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Result> &node) {
|
||||
const auto params = ngraph::builder::makeParams(ov::element::f32, {{2, 2}});
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(params.at(0))};
|
||||
return std::make_shared<ov::Model>(results, params, "ResultGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::Reverse> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 4, 3}});
|
||||
const auto axis = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {0, 1, 2});
|
||||
auto Node = std::make_shared<ov::op::v1::Reverse>(params.at(0), axis, op::v1::Reverse::Mode::INDEX);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "ReverseGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::ReverseSequence > &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams({ov::element::f32, ov::element::i32},
|
||||
{{3, 10}, {3}});
|
||||
auto Node = std::make_shared<ov::op::v0::ReverseSequence>(params.at(0), params.at(1), 0, 1);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "ReverseSequenceGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v7::Roll> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{4, 2, 3}});
|
||||
const auto shift = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {2, 1, 3});
|
||||
const auto axes = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {0, 1, 2});
|
||||
auto Node = std::make_shared<ov::op::v7::Roll>(params.at(0), shift, axes);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "RollGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v5::Round> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{10}});
|
||||
auto Node = std::make_shared<ov::op::v5::Round>(params.at(0), op::v5::Round::RoundMode::HALF_TO_EVEN);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "RoundGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v3::ScatterElementsUpdate> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 2}, {2, 2}});
|
||||
const auto indices = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {2, 2}, {1, 1, 0, 0});
|
||||
const auto axis = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {1}, {0});
|
||||
auto Node = std::make_shared<ov::op::v3::ScatterElementsUpdate>(params.at(0), indices, params.at(1), axis);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "ScatterElementsUpdateGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::Select> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams({ov::element::boolean, ov::element::f32, ov::element::f32},
|
||||
{{2, 2, 2}, {2, 2, 2}, {2, 2, 2}});
|
||||
auto Node = std::make_shared<ov::op::v1::Select>(params.at(0), params.at(1), params.at(2), op::AutoBroadcastType::NONE);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "SelectGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Selu> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{3}});
|
||||
const auto alpha = ngraph::builder::makeConstant<float>(ov::element::f32, {1}, {1.67326324});
|
||||
const auto lambda = ngraph::builder::makeConstant<float>(ov::element::f32, {1}, {1.05070098});
|
||||
auto Node = std::make_shared<ov::op::v0::Selu>(params.at(0), alpha, lambda);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "SeluGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::ShapeOf> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 4, 8, 16, 64}});
|
||||
auto Node = std::make_shared<ov::op::v0::ShapeOf>(params.at(0));
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "ShapeOfGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v3::ShapeOf> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 4, 8, 16, 64}});
|
||||
auto Node = std::make_shared<ov::op::v3::ShapeOf>(params.at(0));
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "ShapeOfGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::ShuffleChannels> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 15, 2, 2}});
|
||||
auto Node = std::make_shared<ov::op::v0::ShuffleChannels>(params.at(0), 1, 5);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "ShuffleChannelsGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v8::Slice> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 4, 3}});
|
||||
const auto start = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {0, 0, 4});
|
||||
const auto stop = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {2, 4, -5});
|
||||
const auto step = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {3, 2, -2});
|
||||
const auto axes = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {0, 1, 2});
|
||||
auto Node = std::make_shared<ov::op::v8::Slice>(params.at(0), start, stop, step, axes);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "SliceGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v4::SoftPlus> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{4, 4}});
|
||||
auto Node = std::make_shared<ov::op::v4::SoftPlus>(params.at(0));
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "SoftPlusGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::Softmax> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 2, 3}});
|
||||
auto Node = std::make_shared<ov::op::v1::Softmax>(params.at(0), 0);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "SoftmaxGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v8::Softmax> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 2, 3}});
|
||||
auto Node = std::make_shared<ov::op::v8::Softmax>(params.at(0), 0);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "SoftmaxGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::SpaceToBatch> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 1, 3, 2, 1}});
|
||||
const auto blockShape = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {5}, {1, 1, 3, 2, 2});
|
||||
const auto padsBegin = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {5}, {0, 0, 1, 0, 3});
|
||||
const auto padsEnd = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {5}, {0, 0, 2, 0, 0});
|
||||
auto Node = std::make_shared<ov::op::v1::SpaceToBatch>(params.at(0), blockShape, padsBegin, padsEnd);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "SpaceToBatchGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::SpaceToDepth> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 2, 4, 4}});
|
||||
auto Node = std::make_shared<ov::op::v0::SpaceToDepth>(params.at(0), "BLOCKS_FIRST", 2);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "SpaceToDepthGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::Split> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 8, 2}});
|
||||
const auto axis = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {}, {1});
|
||||
auto Node = std::make_shared<ov::op::v1::Split>(params.at(0), axis, 4);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "SplitGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Squeeze> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 4, 1, 1, 2}});
|
||||
const auto axes = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {2}, {0, 2});
|
||||
auto Node = std::make_shared<ov::op::v0::Squeeze>(params.at(0), axes);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "SqueezeGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::StridedSlice> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{128, 1}});
|
||||
const auto begin = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {0, 0, 0});
|
||||
const auto end = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {0, 0, 0});
|
||||
const auto stride = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {1, 1, 1});
|
||||
auto Node = std::make_shared<ov::op::v1::StridedSlice>(params.at(0), begin, end, stride,
|
||||
std::vector<int64_t>{0, 1, 1},
|
||||
std::vector<int64_t>{0, 1, 1},
|
||||
std::vector<int64_t>{1, 0, 0},
|
||||
std::vector<int64_t>{1, 0, 0},
|
||||
std::vector<int64_t>{0, 0, 0});
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "StridedSliceGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v4::Swish> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 4}});
|
||||
const auto beta = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {0.6f});
|
||||
auto Node = std::make_shared<ov::op::v4::Swish>(params.at(0), beta);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "SwishGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Tile> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 1, 3}});
|
||||
const auto repeats = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {2}, {2, 1});
|
||||
auto Node = std::make_shared<ov::op::v0::Tile>(params.at(0), repeats);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "TileGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::TopK> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 3, 2}});
|
||||
const auto k = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {}, {3});
|
||||
auto Node = std::make_shared<ov::op::v1::TopK>(params.at(0),
|
||||
k,
|
||||
1,
|
||||
ov::op::v1::TopK::Mode::MAX,
|
||||
ov::op::v1::TopK::SortType::SORT_VALUES);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node->output(0)),
|
||||
std::make_shared<ov::op::v0::Result>(Node->output(1))};
|
||||
return std::make_shared<ov::Model>(results, params, "TopKGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v3::TopK> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 3, 2}});
|
||||
const auto k = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {}, {3});
|
||||
auto Node = std::make_shared<ov::op::v3::TopK>(params.at(0),
|
||||
k,
|
||||
1,
|
||||
ov::op::v3::TopK::Mode::MAX,
|
||||
ov::op::v3::TopK::SortType::SORT_VALUES);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node->output(0)),
|
||||
std::make_shared<ov::op::v0::Result>(Node->output(1))};
|
||||
return std::make_shared<ov::Model>(results, params, "TopKGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::Transpose> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 2, 3}});
|
||||
const auto inputOrder = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {2, 1, 0});
|
||||
auto Node = std::make_shared<ov::op::v1::Transpose>(params.at(0), inputOrder);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "TransposeGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Unsqueeze> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{4, 2}});
|
||||
const auto axes = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {2}, {1, -1});
|
||||
auto Node = std::make_shared<ov::op::v0::Unsqueeze>(params.at(0), axes);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
|
||||
return std::make_shared<ov::Model>(results, params, "UnsqueezeGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::VariadicSplit> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 8, 2, 2}});
|
||||
const auto axis = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {1}, {1});
|
||||
const auto splitLengths = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {4}, {1, 3, 2, 2});
|
||||
auto Node = std::make_shared<ov::op::v1::VariadicSplit>(params.at(0), axis, splitLengths);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node->output(0)),
|
||||
std::make_shared<ov::op::v0::Result>(Node->output(1)),
|
||||
std::make_shared<ov::op::v0::Result>(Node->output(2)),
|
||||
std::make_shared<ov::op::v0::Result>(Node->output(3))};
|
||||
return std::make_shared<ov::Model>(results, params, "VariadicSplitGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generateBinaryEltwise(const std::shared_ptr<ov::op::Op> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 2}, {1, 2}});
|
||||
std::shared_ptr<ov::Node> eltwiseNode;
|
||||
@ -702,6 +1093,262 @@ std::shared_ptr<ov::Model> generateReadValueBase(const std::shared_ptr<ov::op::O
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
std::shared_ptr<ov::Model> generateDeformableConvolutionBase(const std::shared_ptr<ov::op::Op> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 2, 4, 4},
|
||||
{1, 18, 2, 2},
|
||||
{1, 2, 3, 3}});
|
||||
std::shared_ptr<ov::Node> deformableConvolutionNode;
|
||||
if (ov::is_type<ov::op::v1::DeformableConvolution>(node)) {
|
||||
deformableConvolutionNode = std::make_shared<ov::op::v1::DeformableConvolution>(params.at(0), params.at(1), params.at(2),
|
||||
ov::Strides {1, 1},
|
||||
ov::CoordinateDiff {0, 0},
|
||||
ov::CoordinateDiff {0, 0},
|
||||
ov::Strides {1, 1});
|
||||
} else if (ov::is_type<ov::op::v8::DeformableConvolution>(node)) {
|
||||
deformableConvolutionNode = std::make_shared<ov::op::v8::DeformableConvolution>(params.at(0), params.at(1), params.at(2),
|
||||
ov::Strides {1, 1},
|
||||
ov::CoordinateDiff {0, 0},
|
||||
ov::CoordinateDiff {0, 0},
|
||||
ov::Strides {1, 1});
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(deformableConvolutionNode)};
|
||||
return std::make_shared<ov::Model>(results, params, "DeformableConvolutionBaseGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generateDetectionOutputBase(const std::shared_ptr<ov::op::Op> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 8},
|
||||
{2, 6},
|
||||
{2, 1, 8}});
|
||||
ov::op::v0::DetectionOutput::Attributes attrs;
|
||||
ov::op::v8::DetectionOutput::Attributes attrs_v8;
|
||||
attrs.num_classes = 3;
|
||||
attrs_v8.background_label_id = attrs.background_label_id = -1;
|
||||
attrs_v8.top_k = attrs.top_k = -1;
|
||||
attrs_v8.variance_encoded_in_target = attrs.variance_encoded_in_target = true;
|
||||
attrs_v8.keep_top_k = attrs.keep_top_k = {2};
|
||||
attrs_v8.code_type = attrs.code_type = "caffe.PriorBoxParameter.CORNER";
|
||||
attrs_v8.share_location = attrs.share_location = true;
|
||||
attrs_v8.nms_threshold = attrs.nms_threshold = 0.5;
|
||||
attrs_v8.confidence_threshold = attrs.confidence_threshold = 0.3;
|
||||
attrs_v8.clip_after_nms = attrs.clip_after_nms = false;
|
||||
attrs_v8.clip_before_nms = attrs.clip_before_nms = true;
|
||||
attrs_v8.decrease_label_id = attrs.decrease_label_id = false;
|
||||
attrs_v8.normalized = attrs.normalized = true;
|
||||
attrs_v8.input_height = attrs.input_height = 0;
|
||||
attrs_v8.input_width = attrs.input_width = 0;
|
||||
attrs_v8.objectness_score = attrs.objectness_score = 0;
|
||||
|
||||
std::shared_ptr<ov::Node> DetectionOutputNode;
|
||||
if (ov::is_type<ov::op::v0::DetectionOutput>(node)) {
|
||||
DetectionOutputNode = std::make_shared<ov::op::v0::DetectionOutput>(params.at(0), params.at(1), params.at(2), attrs);
|
||||
} else if (ov::is_type<ov::op::v8::DetectionOutput>(node)) {
|
||||
DetectionOutputNode = std::make_shared<ov::op::v8::DetectionOutput>(params.at(0), params.at(1), params.at(2), attrs_v8);
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(DetectionOutputNode)};
|
||||
return std::make_shared<ov::Model>(results, params, "DetectionOutputBaseGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generateEmbeddingBagOffsetsBase(const std::shared_ptr<ov::op::Op> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{5, 2}});
|
||||
const auto indices = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {4}, {}, true);
|
||||
const auto offsets = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {3}, {}, true);
|
||||
const auto default_index = ngraph::builder::makeConstant<int32_t>(ov::element::i32, ov::Shape(), std::vector<int32_t>{0});
|
||||
|
||||
std::shared_ptr<ov::Node> EmbeddingBagOffsetsSumNode;
|
||||
if (ov::is_type<ov::op::v3::EmbeddingBagOffsetsSum>(node)) {
|
||||
EmbeddingBagOffsetsSumNode = std::make_shared<ov::op::v3::EmbeddingBagOffsetsSum>(params.at(0), indices, offsets, default_index);
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(EmbeddingBagOffsetsSumNode)};
|
||||
return std::make_shared<ov::Model>(results, params, "EmbeddingBagOffsetsBaseGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generateEmbeddingBagPackedBase(const std::shared_ptr<ov::op::Op> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{5, 2}});
|
||||
const auto indices = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2, 3}, {}, true);
|
||||
|
||||
std::shared_ptr<ov::Node> EmbeddingBagPackedSumNode;
|
||||
if (ov::is_type<ov::op::v3::EmbeddingBagPackedSum>(node)) {
|
||||
EmbeddingBagPackedSumNode = std::make_shared<ov::op::v3::EmbeddingBagPackedSum>(params.at(0), indices);
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(EmbeddingBagPackedSumNode)};
|
||||
return std::make_shared<ov::Model>(results, params, "EmbeddingBagPackedBaseGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generateFFTBase(const std::shared_ptr<ov::op::Op> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 10, 10, 2}});
|
||||
const auto axes = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {1}, {2});
|
||||
|
||||
std::shared_ptr<ov::Node> FFTBaseNode;
|
||||
if (ov::is_type<ov::op::v7::DFT>(node)) {
|
||||
FFTBaseNode = std::make_shared<ov::op::v7::DFT>(params.at(0), axes);
|
||||
} else if (ov::is_type<ov::op::v7::IDFT>(node)) {
|
||||
FFTBaseNode = std::make_shared<ov::op::v7::IDFT>(params.at(0), axes);
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(FFTBaseNode)};
|
||||
return std::make_shared<ov::Model>(results, params, "FFTBaseGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generateGatherBase(const std::shared_ptr<ov::op::Op> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::i32, {{2, 2, 3, 3}, {2}});
|
||||
const auto axis = ngraph::builder::makeConstant<int64_t>(ov::element::i64, ov::Shape(), std::vector<int64_t>{2});
|
||||
|
||||
std::shared_ptr<ov::Node> GatherBaseNode;
|
||||
if (ov::is_type<ov::op::v1::Gather>(node)) {
|
||||
GatherBaseNode = std::make_shared<ov::op::v1::Gather>(params.at(0), params.at(1), axis);
|
||||
} else if (ov::is_type<ov::op::v7::Gather>(node)) {
|
||||
GatherBaseNode = std::make_shared<ov::op::v7::Gather>(params.at(0), params.at(1), axis);
|
||||
} else if (ov::is_type<ov::op::v8::Gather>(node)) {
|
||||
GatherBaseNode = std::make_shared<ov::op::v8::Gather>(params.at(0), params.at(1), axis);
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(GatherBaseNode)};
|
||||
return std::make_shared<ov::Model>(results, params, "GatherBaseGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generateGatherNDBase(const std::shared_ptr<ov::op::Op> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::i32, {{2, 3, 4, 2}, {2, 3, 3, 2}});
|
||||
|
||||
std::shared_ptr<ov::Node> GatherNDBaseNode;
|
||||
if (ov::is_type<ov::op::v5::GatherND>(node)) {
|
||||
GatherNDBaseNode = std::make_shared<ov::op::v5::GatherND>(params.at(0), params.at(1));
|
||||
} else if (ov::is_type<ov::op::v8::GatherND>(node)) {
|
||||
GatherNDBaseNode = std::make_shared<ov::op::v8::GatherND>(params.at(0), params.at(1));
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(GatherNDBaseNode)};
|
||||
return std::make_shared<ov::Model>(results, params, "GatherNDBaseGraph");
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generateRNNCellBase(const std::shared_ptr<ov::op::Op> &node) {
|
||||
std::shared_ptr<ov::Node> RNNCellBaseNode;
|
||||
if (ov::is_type<ov::op::v3::GRUCell>(node)) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 3}, {2, 3}});
|
||||
const auto W = ngraph::builder::makeConstant<float>(ov::element::f32, {9, 3}, {}, true);
|
||||
const auto R = ngraph::builder::makeConstant<float>(ov::element::f32, {9, 3}, {}, true);
|
||||
const auto B = ngraph::builder::makeConstant<float>(ov::element::f32, {9}, {}, true);
|
||||
RNNCellBaseNode = std::make_shared<ov::op::v3::GRUCell>(params.at(0), params.at(1),
|
||||
W, R, B, 3);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(RNNCellBaseNode)};
|
||||
return std::make_shared<ov::Model>(results, params, "RNNCellBaseGraph");
|
||||
} else if (ov::is_type<ov::op::v0::LSTMCell>(node)) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 3}, {2, 3}, {2, 3}});
|
||||
const auto W = ngraph::builder::makeConstant<float>(ov::element::f32, {12, 3}, {}, true);
|
||||
const auto R = ngraph::builder::makeConstant<float>(ov::element::f32, {12, 3}, {}, true);
|
||||
const auto B = ngraph::builder::makeConstant<float>(ov::element::f32, {12}, {}, true);
|
||||
const auto P = ngraph::builder::makeConstant<float>(ov::element::f32, {9}, {}, true);
|
||||
RNNCellBaseNode = std::make_shared<ov::op::v0::LSTMCell>(params.at(0), params.at(1), params.at(2),
|
||||
W, R, B, P, 3);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(0)),
|
||||
std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(1))};
|
||||
//return std::make_shared<ov::Model>(results, params, "RNNCellBaseGraph");
|
||||
return nullptr; // Temporary nullptr return due to crash in mkldnn
|
||||
} else if (ov::is_type<ov::op::v4::LSTMCell>(node)) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 3}, {2, 3}, {2, 3}});
|
||||
const auto W = ngraph::builder::makeConstant<float>(ov::element::f32, {12, 3}, {}, true);
|
||||
const auto R = ngraph::builder::makeConstant<float>(ov::element::f32, {12, 3}, {}, true);
|
||||
const auto B = ngraph::builder::makeConstant<float>(ov::element::f32, {12}, {}, true);
|
||||
RNNCellBaseNode = std::make_shared<ov::op::v4::LSTMCell>(params.at(0), params.at(1), params.at(2),
|
||||
W, R, B, 3);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(0)),
|
||||
std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(1))};;
|
||||
return std::make_shared<ov::Model>(results, params, "RNNCellBaseGraph");
|
||||
} else if (ov::is_type<ov::op::v5::LSTMSequence>(node)) {
|
||||
const auto params = ngraph::builder::makeDynamicParams({ov::element::f32, ov::element::f32, ov::element::f32, ov::element::i64},
|
||||
{{5, 10, 10}, {5, 1, 10}, {5, 1, 10}, {5}});
|
||||
const auto W = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 40, 10}, {}, true);
|
||||
const auto R = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 40, 10}, {}, true);
|
||||
const auto B = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 40}, {}, true);
|
||||
RNNCellBaseNode = std::make_shared<ov::op::v5::LSTMSequence>(params.at(0), params.at(1), params.at(2), params.at(3),
|
||||
W, R, B, 10, ov::op::RecurrentSequenceDirection::FORWARD);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(0)),
|
||||
std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(1)),
|
||||
std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(2))};
|
||||
return std::make_shared<ov::Model>(results, params, "RNNCellBaseGraph");
|
||||
} else if (ov::is_type<ov::op::v0::RNNCell>(node)) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 3}, {2, 3}});
|
||||
const auto W = ngraph::builder::makeConstant<float>(ov::element::f32, {3, 3}, {}, true);
|
||||
const auto R = ngraph::builder::makeConstant<float>(ov::element::f32, {3, 3}, {}, true);
|
||||
const auto B = ngraph::builder::makeConstant<float>(ov::element::f32, {3}, {}, true);
|
||||
RNNCellBaseNode = std::make_shared<ov::op::v0::RNNCell>(params.at(0), params.at(1),
|
||||
W, R, B, 3);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(RNNCellBaseNode)};
|
||||
return std::make_shared<ov::Model>(results, params, "RNNCellBaseGraph");
|
||||
} else if (ov::is_type<ov::op::v5::RNNSequence>(node)) {
|
||||
const auto params = ngraph::builder::makeDynamicParams({ov::element::f32, ov::element::f32, ov::element::i64},
|
||||
{{2, 5, 3}, {2, 1, 3}, {2}});
|
||||
const auto W = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 3, 3}, {}, true);
|
||||
const auto R = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 3, 3}, {}, true);
|
||||
const auto B = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 3}, {}, true);
|
||||
RNNCellBaseNode = std::make_shared<ov::op::v5::RNNSequence>(params.at(0), params.at(1), params.at(2),
|
||||
W, R, B, 3, ov::op::RecurrentSequenceDirection::FORWARD);
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(0)),
|
||||
std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(1))};
|
||||
return std::make_shared<ov::Model>(results, params, "RNNCellBaseGraph");
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
std::shared_ptr<ov::Model> generateSubGraphOp(const std::shared_ptr<ov::op::Op> &node) {
|
||||
const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 2}, {2, 2}, {2, 2}});
|
||||
const auto params_body = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 2}, {2, 2}, {2, 2}});
|
||||
const auto body_condition = ngraph::builder::makeConstant<bool>(ov::element::boolean, ov::Shape{1}, {true});
|
||||
const auto trip_count = ngraph::builder::makeConstant<int64_t>(ngraph::element::i64, ov::Shape{1}, {3});
|
||||
const auto exec_condition = ngraph::builder::makeConstant<bool>(ov::element::boolean, ov::Shape{1}, {true});
|
||||
// Body
|
||||
auto sum = std::make_shared<ov::op::v1::Add>(params_body.at(0), params_body.at(1));
|
||||
auto Zo = std::make_shared<ov::op::v1::Multiply>(sum, params_body.at(2));
|
||||
auto body = std::make_shared<ov::Model>(ov::OutputVector{body_condition, Zo}, params_body);
|
||||
|
||||
ov::Output<ov::Node> SubGraphOpNode;
|
||||
if (ov::is_type<ov::op::v0::TensorIterator>(node)) {
|
||||
auto tensor_iterator = std::make_shared<ov::op::v0::TensorIterator>();
|
||||
tensor_iterator->set_function(body);
|
||||
|
||||
tensor_iterator->set_sliced_input(params_body.at(0), params.at(0), 0, 1, 1, -1, 1);
|
||||
tensor_iterator->set_sliced_input(params_body.at(1), params.at(1), 0, 1, 1, -1, 0);
|
||||
tensor_iterator->set_merged_input(params_body.at(2), params.at(2), Zo);
|
||||
|
||||
// Output 0 is last Zo
|
||||
SubGraphOpNode = tensor_iterator->get_iter_value(Zo, -1);
|
||||
} else if (ov::is_type<ov::op::v5::Loop>(node)) {
|
||||
auto loop = std::make_shared<ov::op::v5::Loop>(trip_count, exec_condition);
|
||||
loop->set_function(body);
|
||||
|
||||
loop->set_invariant_input(params_body.at(0), params.at(0));
|
||||
loop->set_invariant_input(params_body.at(1), params.at(1));
|
||||
loop->set_merged_input(params_body.at(2), params.at(2), Zo);
|
||||
|
||||
loop->set_special_body_ports(ov::op::v5::Loop::SpecialBodyPorts{-1, 0});
|
||||
SubGraphOpNode = loop->get_iter_value(Zo, -1);
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
ov::ResultVector results{std::make_shared<ov::op::v0::Result>(SubGraphOpNode)};
|
||||
return std::make_shared<ov::Model>(results, params, "SubGraphOpGraph");
|
||||
}
|
||||
} // namespace
|
||||
|
||||
template <typename T>
|
||||
@ -724,6 +1371,24 @@ std::shared_ptr<ov::Model> generateGraph() {
|
||||
return generateNmsBase(node);
|
||||
} else if (ov::is_type<ov::op::util::ReadValueBase>(node)) {
|
||||
return generateReadValueBase(node);
|
||||
} else if (ov::is_type<ov::op::util::DeformableConvolutionBase>(node)) {
|
||||
return generateDeformableConvolutionBase(node);
|
||||
} else if (ov::is_type<ov::op::util::DetectionOutputBase>(node)) {
|
||||
return generateDetectionOutputBase(node);
|
||||
} else if (ov::is_type<ov::op::util::EmbeddingBagOffsetsBase>(node)) {
|
||||
return generateEmbeddingBagOffsetsBase(node);
|
||||
} else if (ov::is_type<ov::op::util::EmbeddingBagPackedBase>(node)) {
|
||||
return generateEmbeddingBagPackedBase(node);
|
||||
} else if (ov::is_type<ov::op::util::FFTBase>(node)) {
|
||||
return generateFFTBase(node);
|
||||
} else if (ov::is_type<ov::op::util::GatherBase>(node)) {
|
||||
return generateGatherBase(node);
|
||||
} else if (ov::is_type<ov::op::util::GatherNDBase>(node)) {
|
||||
return generateGatherNDBase(node);
|
||||
} else if (ov::is_type<ov::op::util::RNNCellBase>(node)) {
|
||||
return generateRNNCellBase(node);
|
||||
} else if (ov::is_type<ov::op::util::SubGraphOp>(node)) {
|
||||
return generateSubGraphOp(node);
|
||||
}
|
||||
|
||||
return generate(node);
|
||||
@ -747,4 +1412,4 @@ OpGenerator getOpGeneratorMap() {
|
||||
|
||||
} // namespace subgraph
|
||||
} // namespace test
|
||||
} // namespace ov
|
||||
} // namespace ov
|
||||
Loading…
Reference in New Issue
Block a user