Eliminate builder functions

openvinotoolkit · Aug 10, 2023 · 30c1cde · 30c1cde
1 parent 0193980
commit 30c1cde
Show file tree

Hide file tree

Showing 11 changed files with 65 additions and 64 deletions.
diff --git a/.../tests/functional/shared_tests_instances/single_layer_tests/convolution_backprop_data.cpp b/.../tests/functional/shared_tests_instances/single_layer_tests/convolution_backprop_data.cpp
@@ -92,12 +92,17 @@ class ConvolutionBackpropDataExtendedLayerTest
                                                           bool addBiases = false,
                                                           const std::vector<float> &filterWeights = {},
                                                           const std::vector<float> &biasesWeights = {}) {
-        bool randomFilterWeights = filterWeights.empty();
         auto shape = in.get_shape();
         std::vector<size_t> filterWeightsShape = {shape[1], numOutChannels};
         filterWeightsShape.insert(filterWeightsShape.end(), filterSize.begin(), filterSize.end());
-        auto filterWeightsNode =
-            ngraph::builder::makeConstant(type, filterWeightsShape, filterWeights, randomFilterWeights);
+        std::shared_ptr<ov::op::v0::Constant> filterWeightsNode;
+        if (filterWeights.empty()) {
+                ov::Tensor random_tensor(type, filterWeightsShape);
+                ov::test::utils::fill_tensor_random(random_tensor);
+                auto constant = std::make_shared<ov::op::v0::Constant>(random_tensor);
+        } else {
+            filterWeightsNode = std::make_shared<ov::op::v0::Constant>(type, filterWeightsShape, filterWeights);
+        }
 
         return makeConvolutionBackpropData(in,
                                            filterWeightsNode,
@@ -149,10 +154,9 @@ class ConvolutionBackpropDataExtendedLayerTest
         std::tie(kernel, stride, padBegin, padEnd, dilation, convOutChannels, padType, outputPad) =
             convBackpropDataParams;
         auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
-        ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape)))};
+        ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
 
-        auto outputShapeNode =
-            ngraph::builder::makeConstant(ov::element::Type_t::i64, {outputShapeData.size()}, outputShapeData);
+        auto outputShapeNode = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{outputShapeData.size()}, outputShapeData);
         auto paramOuts =
             ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ov::op::v0::Parameter>(params));
         auto convBackpropData = std::dynamic_pointer_cast<ngraph::opset1::ConvolutionBackpropData>(

diff --git a/...ts/functional/shared_tests_instances/single_layer_tests/convolution_backprop_data_add.cpp b/...ts/functional/shared_tests_instances/single_layer_tests/convolution_backprop_data_add.cpp
@@ -94,9 +94,15 @@ class ConvolutionBackpropDataAddExtendedLayerTest
         auto shape = in.get_shape();
         std::vector<size_t> filterWeightsShape = {shape[1], numOutChannels};
         filterWeightsShape.insert(filterWeightsShape.end(), filterSize.begin(), filterSize.end());
-        auto filterWeightsNode =
-            ngraph::builder::makeConstant(type, filterWeightsShape, filterWeights, randomFilterWeights);
 
+        std::shared_ptr<ov::Node> filterWeightsNode;
+        if (filterWeights.empty()) {
+                ov::Tensor random_tensor(type, filterWeightsShape);
+                ov::test::utils::fill_tensor_random(random_tensor);
+                filterWeightsNode = std::make_shared<ov::op::v0::Constant>(random_tensor);
+        } else {
+            filterWeightsNode = std::make_shared<ov::op::v0::Constant>(type, filterWeightsShape, filterWeights);
+        }
         return makeConvolutionBackpropData(in,
                                            filterWeightsNode,
                                            output,
@@ -147,10 +153,9 @@ class ConvolutionBackpropDataAddExtendedLayerTest
         std::tie(kernel, stride, padBegin, padEnd, dilation, convOutChannels, padType, outputPad) =
             convBackpropDataParams;
         auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
-        ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape)))};
+        ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
 
-        auto outputShapeNode =
-            ngraph::builder::makeConstant(ov::element::Type_t::i64, {outputShapeData.size()}, outputShapeData);
+        auto outputShapeNode = std::make_shared<ov::op::v0::Constant>(ov::element::Type_t::i64, ov::Shape{outputShapeData.size()}, outputShapeData);
         auto paramOuts =
             ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ov::op::v0::Parameter>(params));
         auto convBackpropData = std::dynamic_pointer_cast<ngraph::opset1::ConvolutionBackpropData>(
@@ -164,8 +169,11 @@ class ConvolutionBackpropDataAddExtendedLayerTest
                                         dilation,
                                         padType,
                                         convOutChannels));
-        auto addConstant = ngraph::builder::makeConstant(ngPrc, outputShapeData, outputShapeData, true);
-        auto add = ngraph::builder::makeEltwise(convBackpropData, addConstant, ngraph::helpers::EltwiseTypes::ADD);
+
+        ov::Tensor random_tensor(ngPrc, outputShapeData);
+        ov::test::utils::fill_tensor_random(random_tensor);
+        auto addConstant = std::make_shared<ov::op::v0::Constant>(random_tensor);
+        auto add = std::make_shared<ov::op::v1::Add>(convBackpropData, addConstant);
         ov::ResultVector results{std::make_shared<ngraph::opset1::Result>(add)};
         function = std::make_shared<ngraph::Function>(results, params, "convolutionBackpropData");
     }

diff --git a/...s/functional/shared_tests_instances/single_layer_tests/convolution_biasadd_activation.hpp b/...s/functional/shared_tests_instances/single_layer_tests/convolution_biasadd_activation.hpp
@@ -122,13 +122,13 @@ class BasicConvolutionBiasAddActivationLayerTest
         }
         auto biasLayer = std::make_shared<ov::op::v0::Constant>(ngNetPrc, biasShape);
 
-        auto biasAddLayer = ngraph::builder::makeEltwise(convLayer, biasLayer, ngraph::helpers::EltwiseTypes::ADD);
+        auto biasAddLayer = std::make_shared<ov::op::v1::Add>(convLayer, biasLayer);
 
         std::shared_ptr<ov::Node> lastNode;
         if constexpr (HasAddNode) {
             auto addParam = std::make_shared<ngraph::opset1::Parameter>(ngNetPrc, convLayer->get_output_shape(0));
             params.push_back(addParam);
-            auto addLayer = ngraph::builder::makeEltwise(biasAddLayer, addParam, ngraph::helpers::EltwiseTypes::ADD);
+            auto addLayer = std::make_shared<ov::op::v1::Add>(biasAddLayer, addParam);
             lastNode = addLayer;
         } else {
             lastNode = biasAddLayer;
@@ -163,7 +163,7 @@ class BasicConvolutionBiasAddActivationLayerTest
         }
 
         auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
-        ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape)))};
+        ov::ParameterVector params {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
 
         auto paramOuts =
             ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ov::op::v0::Parameter>(params));

diff --git a/...nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/cuda_eltwise.cpp b/...nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/cuda_eltwise.cpp
@@ -208,7 +208,7 @@ void CudaEltwiseLayerTest::SetUp() {
 
     init_input_shapes(shapes);
 
-    ov::ParameterVector parameters {std::make_shared<ov::op::v0::Parameter>(netType, inputDynamicShapes.front)};
+    ov::ParameterVector parameters {std::make_shared<ov::op::v0::Parameter>(netType, inputDynamicShapes.front())};
 
     ov::PartialShape shape_input_secondary;
     switch (opType) {
@@ -247,15 +247,17 @@ void CudaEltwiseLayerTest::SetUp() {
                         [](const auto& value) { return static_cast<int>(static_cast<float>(value)) == 0; },
                         1);
                 }
-                secondaryInput = ngraph::builder::makeConstant(netType, shape, data);
+                secondaryInput = std::make_shared<ov::op::v0::Constant>(netType, shape, data);
                 break;
             }
             case ngraph::helpers::EltwiseTypes::POWER: {
-                secondaryInput = ngraph::builder::makeConstant<float>(netType, shape, {}, is_random, 3);
+                ov::Tensor random_tensor(netType, shape);
+                ov::test::utils::fill_tensor_random(random_tensor, 3, -3);
+                secondaryInput = std::make_shared<ov::op::v0::Constant>(random_tensor);
                 break;
             }
             default: {
-                secondaryInput = ngraph::builder::makeConstant<float>(netType, shape, data);
+                secondaryInput = std::make_shared<ov::op::v0::Constant>(netType, shape, data);
             }
         }
     }

diff --git a/...dia_plugin/tests/functional/shared_tests_instances/single_layer_tests/fully_connected.cpp b/...dia_plugin/tests/functional/shared_tests_instances/single_layer_tests/fully_connected.cpp
@@ -3,7 +3,6 @@
 //
 
 #include <cuda_test_constants.hpp>
-#include <ngraph_functions/builders.hpp>
 #include <vector>
 
 #include "finite_comparer.hpp"
@@ -95,10 +94,8 @@ class FullyConnectedLayerTest : public testing::WithParamInterface<FullyConnecte
         auto thirdInput = std::make_shared<ov::op::v0::Constant>(ngPrc, shapeRelatedParams.input3);
         auto paramOuts =
             ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ov::op::v0::Parameter>(params));
-        auto MatMul = std::dynamic_pointer_cast<ov::op::v0::MatMul>(ngraph::builder::makeMatMul(
-            paramOuts[0], secondaryInput, shapeRelatedParams.input1.second, shapeRelatedParams.input2.second));
-        auto Add = std::dynamic_pointer_cast<ov::op::v1::Add>(
-            ngraph::builder::makeEltwise(MatMul, thirdInput, ngraph::helpers::EltwiseTypes::ADD));
+        auto MatMul = std::make_shared<ov::op::v0::MatMul>(paramOuts[0], secondaryInput, shapeRelatedParams.input1.second, shapeRelatedParams.input2.second);
+        auto Add = std::make_shared<ov::op::v1::Add>(MatMul, thirdInput);
         ov::ResultVector results{std::make_shared<ngraph::opset1::Result>(Add)};
         function = std::make_shared<ngraph::Function>(results, params, "FullyConnected");
     }
@@ -210,20 +207,16 @@ class FullyConnectedLayer2MatMulTest : public testing::WithParamInterface<FullyC
             matmul1SecondaryInput = std::make_shared<ov::op::v0::Constant>(ngPrc, shapeRelatedParams.matmul1_input2.first);
         }
 
-        auto paramOuts =
-            ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ov::op::v0::Parameter>(params));
-        auto matMul0 = std::dynamic_pointer_cast<ov::op::v0::MatMul>(
-            ngraph::builder::makeMatMul(paramOuts[0],
-                                        matmul0SecondaryInput,
-                                        shapeRelatedParams.matmul1_input1.second,
-                                        shapeRelatedParams.matmul1_input2.second));
-        auto matMul1 = std::dynamic_pointer_cast<ov::op::v0::MatMul>(
-            ngraph::builder::makeMatMul(paramOuts[1],
-                                        matmul1SecondaryInput,
-                                        shapeRelatedParams.matmul2_input1.second,
-                                        shapeRelatedParams.matmul2_input2.second));
-        auto Add = std::dynamic_pointer_cast<ov::op::v1::Add>(
-            ngraph::builder::makeEltwise(matMul0, matMul1, ngraph::helpers::EltwiseTypes::ADD));
+        auto paramOuts = ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ov::op::v0::Parameter>(params));
+        auto matMul0 = std::make_shared<ov::op::v0::MatMul>(paramOuts[0],
+                                                            matmul0SecondaryInput,
+                                                            shapeRelatedParams.matmul1_input1.second,
+                                                            shapeRelatedParams.matmul1_input2.second);
+        auto matMul1 = std::make_shared<ov::op::v0::MatMul>(paramOuts[1],
+                                                            matmul1SecondaryInput,
+                                                            shapeRelatedParams.matmul2_input1.second,
+                                                            shapeRelatedParams.matmul2_input2.second);
+        auto Add = std::make_shared<ov::op::v1::Add>(matMul0, matMul1);
         ov::ResultVector results{std::make_shared<ngraph::opset1::Result>(Add)};
         function = std::make_shared<ngraph::Function>(results, params, "FullyConnected");
     }

diff --git a/...les/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/gru_cell.cpp b/...les/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/gru_cell.cpp
@@ -34,10 +34,9 @@ class CUDNNGRUCellTest : public UnsymmetricalComparer<GRUCellTest> {
         int seed = SEED_FIRST;
         for (const auto& op : ops) {
             if (std::dynamic_pointer_cast<ngraph::opset1::Constant>(op)) {
-                const auto constant = ngraph::builder::makeConstant(
-                    op->get_element_type(), op->get_shape(), std::vector<float>{}, true, up_to, start_from, seed);
-                function->replace_node(op, constant);
-                ++seed;
+                ov::Tensor random_tensor(op->get_element_type(), op->get_shape());
+                ov::test::utils::fill_tensor_random(random_tensor, up_to - start_from, start_from, 1, seed++);
+                function->replace_node(op, std::make_shared<ov::op::v0::Constant>(random_tensor));
             }
         }
 

diff --git a/...nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/gru_sequence.cpp b/...nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/gru_sequence.cpp
@@ -27,9 +27,9 @@ class CUDNNGRUSequenceTest : public UnsymmetricalComparer<GRUSequenceTest> {
         for (const auto& op : ops) {
             if (std::dynamic_pointer_cast<ngraph::opset1::Constant>(op)) {
                 if (op->get_element_type() == ov::element::Type_t::f32) {
-                    const auto constant = ngraph::builder::makeConstant(
-                        op->get_element_type(), op->get_shape(), std::vector<float>{}, true, up_to, start_from, seed++);
-                    function->replace_node(op, constant);
+                    ov::Tensor random_tensor(op->get_element_type(), op->get_shape());
+                    ov::test::utils::fill_tensor_random(random_tensor, up_to - start_from, start_from, 1, seed++);
+                    function->replace_node(op, std::make_shared<ov::op::v0::Constant>(random_tensor));
                 }
             }
         }
@@ -57,9 +57,9 @@ class LPCNetCUDNNGRUSequenceTest : public UnsymmetricalComparer<GRUSequenceTest>
         for (const auto& op : ops) {
             if (std::dynamic_pointer_cast<ngraph::opset1::Constant>(op)) {
                 if (op->get_element_type() == ov::element::Type_t::f32) {
-                    const auto constant = ngraph::builder::makeConstant(
-                        op->get_element_type(), op->get_shape(), std::vector<float>{}, true, up_to, start_from, seed++);
-                    function->replace_node(op, constant);
+                    ov::Tensor random_tensor(op->get_element_type(), op->get_shape());
+                    ov::test::utils::fill_tensor_random(random_tensor, up_to - start_from, start_from, 1, seed++);
+                    function->replace_node(op, std::make_shared<ov::op::v0::Constant>(random_tensor));
                 }
             }
         }

diff --git a/...es/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/lstm_cell.cpp b/...es/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/lstm_cell.cpp
@@ -37,8 +37,9 @@ class CUDNNLSTMCellTest : public LSTMCellTest {
         int seed = SEED_FIRST;
         for (const auto& op : ops) {
             if (std::dynamic_pointer_cast<ngraph::opset1::Constant>(op)) {
-                const auto constant = ngraph::builder::makeConstant(
-                    op->get_element_type(), op->get_shape(), std::vector<float>{}, true, up_to, start_from, seed);
+                ov::Tensor random_tensor(op->get_element_type(), op->get_shape());
+                ov::test::utils::fill_tensor_random(random_tensor, up_to - start_from, start_from, 1, seed);
+                auto constant = std::make_shared<ov::op::v0::Constant>(random_tensor);
                 function->replace_node(op, constant);
                 ++seed;
             }

diff --git a/...vidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/lstm_sequence.cpp b/...vidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/lstm_sequence.cpp
@@ -26,14 +26,9 @@ class CUDALSTMSequenceTest : public UnsymmetricalComparer<LSTMSequenceTest> {
         for (const auto& op : ops) {
             if (std::dynamic_pointer_cast<ngraph::opset1::Constant>(op)) {
                 if (op->get_element_type() == ov::element::Type_t::f32) {
-                    const auto constant = ngraph::builder::makeConstant(op->get_element_type(),
-                                                                        op->get_shape(),
-                                                                        std::vector<float>{},
-                                                                        true,
-                                                                        up_to,
-                                                                        start_from,
-                                                                        counter++);
-                    function->replace_node(op, constant);
+                    ov::Tensor random_tensor(op->get_element_type(), op->get_shape());
+                    ov::test::utils::fill_tensor_random(random_tensor, up_to - start_from, start_from, 1, counter++);
+                    function->replace_node(op, std::make_shared<ov::op::v0::Constant>(random_tensor));
                 }
             }
         }

diff --git a/modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/range.cpp b/modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/range.cpp
@@ -220,9 +220,9 @@ struct CudaRangeLayerTest : public testing::WithParamInterface<CudaRangeParams>,
         CUDA::Device device{};
         const bool optimizeOption = false;
         NodeVector params;
-        params.push_back(builder::makeConstant<decltype(start)>(Type(start_type), std::vector<size_t>(), {start}));
-        params.push_back(builder::makeConstant<decltype(stop)>(Type(Type_t::f32), std::vector<size_t>(), {stop}));
-        params.push_back(builder::makeConstant<decltype(step)>(Type(step_type), std::vector<size_t>(), {step}));
+        params.push_back(std::make_shared<ov::op::v0::Constant>(ov::element::Type(start_type), ov::Shape(), start));
+        params.push_back(std::make_shared<ov::op::v0::Constant>(ov::element::f32, ov::Shape(), stop));
+        params.push_back(std::make_shared<ov::op::v0::Constant>(ov::element::Type(step_type), ov::Shape(), step));
         params[0]->set_friendly_name("start");
         params[1]->set_friendly_name("stop");
         params[2]->set_friendly_name("step");

diff --git a/modules/nvidia_plugin/tests/unit/test_networks.hpp b/modules/nvidia_plugin/tests/unit/test_networks.hpp
@@ -18,8 +18,7 @@ inline std::shared_ptr<ngraph::Function> CreateMatMulTestNetwork() {
     auto secondaryInput = std::make_shared<ov::op::v0::Constant>(ngPrc, ov::Shape{3, 2, 10, 20});
     auto paramOuts =
         ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes<ov::op::v0::Parameter>(params));
-    auto MatMul = std::dynamic_pointer_cast<ov::op::v0::MatMul>(
-        ngraph::builder::makeMatMul(paramOuts[0], secondaryInput, false, false));
+    auto MatMul = std::make_shared<ov::op::v0::MatMul>(paramOuts[0], secondaryInput, false, false);
     ov::ResultVector results{std::make_shared<ngraph::opset1::Result>(MatMul)};
     return std::make_shared<ngraph::Function>(results, params, "MatMul");
 }