[LPT] Plugin tests cleanup

src/common/low_precision_transformations/tests/fake_quantize_transformation.cpp

@@ -80,7 +80,6 @@ class FakeQuantizeTransformation : public LayerTransformation,
                                 .setDefaultPrecisions(defaultPrecisions);
 
         actualFunction = ov::builder::subgraph::FakeQuantizeFunction::getOriginal(
-            TestTransformationParams::toParams(fakeQuantizeOnData.params),
             precision,
             shape,
             fakeQuantizeOnData.actual,
@@ -97,7 +96,6 @@ class FakeQuantizeTransformation : public LayerTransformation,
         transform.transform(actualFunction);
 
         referenceFunction = ov::builder::subgraph::FakeQuantizeFunction::getReference(
-            TestTransformationParams::toParams(fakeQuantizeOnData.params),
             precision,
             shape,
             params.updatePrecisions,

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/aarch64/fully_connected_transformation.cpp

@@ -65,10 +65,6 @@ const std::vector<FullyConnectedShapes> shapes = {
     }
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams()
-};
-
 const std::vector<FullyConnectedParams> activations = {
     {
         true,  // activation
@@ -105,7 +101,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FullyConnectedTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::ValuesIn(shapes),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn({ov::element::i8 /*, ov::element::u8*/}),
         ::testing::ValuesIn(activations),
         ::testing::Values("gemm_acl_i8")),

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/assign_and_read_value_transformation.cpp

@@ -21,11 +21,6 @@ const std::vector<size_t> opsetVersions = {
     6
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-};
-
 const std::vector<LayerTestsDefinitions::AssignAndReadValueTransformationParam> params{
     // u8
     {
@@ -47,7 +42,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, AssignAndReadValueTransformation,
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
         ::testing::ValuesIn(opsetVersions),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     AssignAndReadValueTransformation::getTestCaseName);
 

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/clamp_transformation.cpp

@@ -16,13 +16,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<LayerTestsDefinitions::ClampTransformationParam> params{
     // tensor quantization
     {
@@ -80,7 +73,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ClampTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ClampTransformation::getTestCaseName);
 

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/concat_with_child_and_output.cpp

@@ -14,10 +14,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams()
-};
-
 const std::vector<ConcatWithChildAndOutputTransformationParam> testValues = {
     // U8
     {
@@ -46,7 +42,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConcatWithChildAndOutputTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 6, 10, 10 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(testValues),
-        ::testing::ValuesIn(trasformationParamValues)),
+        ::testing::ValuesIn(testValues)),
     ConcatWithChildAndOutputTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/concat_with_different_precision_on_children.cpp

@@ -14,10 +14,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<ConcatWithDifferentChildrenTransformationParam> testValues = {
     // U8
     {
@@ -56,7 +52,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConcatWithDifferentChildrenTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 6, 10, 10 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(testValues),
-        ::testing::ValuesIn(trasformationParamValues)),
+        ::testing::ValuesIn(testValues)),
     ConcatWithDifferentChildrenTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/concat_with_intermediate_transformation.cpp

@@ -14,13 +14,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<bool> transparentIntermediateValues = { true, false };
 const std::vector<bool> multiChannelValues = { /*true,*/ false };
 
@@ -34,7 +27,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConcatWithIntermediateTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::ValuesIn(shapes),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(transparentIntermediateValues),
         ::testing::ValuesIn(multiChannelValues)),
     ConcatWithIntermediateTransformation::getTestCaseName);

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/concat_with_neighbors_transformation.cpp

@@ -14,13 +14,6 @@ const std::vector<ov::element::Type> precisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<ov::PartialShape> shapes = {
     { 1, 3, 16, 16 },
     { 4, 3, 16, 16 }
@@ -31,7 +24,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConcatWithNeighborsGraphTransformation,
         ::testing::ValuesIn(precisions),
         ::testing::ValuesIn(shapes),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::Values("convolution_addition_original"),
         ::testing::Values("u8")),
     ConcatWithNeighborsGraphTransformation::getTestCaseName);

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/concat_with_split_transformation.cpp

@@ -14,13 +14,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<ConcatWithSplitTransformationParam> testValues = {
     // U8
     {
@@ -49,7 +42,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConcatWithSplitTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 6, 10, 10 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(testValues),
-        ::testing::ValuesIn(trasformationParamValues)),
+        ::testing::ValuesIn(testValues)),
     ConcatWithSplitTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/convolution_backprop_data_transformation.cpp

@@ -14,10 +14,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(true)
-};
-
 const std::vector<LayerTestsDefinitions::ConvolutionBackpropDataTransformationParam> params = {
     // FQ on weights
     {
@@ -114,7 +110,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT_4D, ConvolutionBackpropDataTransformation,
         ::testing::ValuesIn(inputShapes_4D),
         ::testing::ValuesIn(outputShapes_4D),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ConvolutionBackpropDataTransformation::getTestCaseName);
 
@@ -149,7 +144,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT_3D, ConvolutionBackpropDataTransformation,
         ::testing::ValuesIn(inputShapes_3D),
         ::testing::ValuesIn(outputShapes_3D),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params_3D)),
     ConvolutionBackpropDataTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/convolution_qdq_transformation.cpp

@@ -15,11 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-};
-
 const std::vector<LayerTestsDefinitions::ConvolutionQDqTransformationParam> params = {
     // Actual:
     //
@@ -262,7 +257,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConvolutionQDqTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::ValuesIn(shapes),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ConvolutionQDqTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/convolution_transformation.cpp

@@ -15,10 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams()
-};
-
 const std::vector<LayerTestsDefinitions::ConvolutionTransformationParam> params = {
     {
         { 256ul, ov::Shape { 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 25.5f } },
@@ -162,7 +158,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConvolutionTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::ValuesIn(shapes),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ConvolutionTransformation::getTestCaseName);
 
@@ -186,7 +181,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConvolutionWIthIncorrectWeightsTransformatio
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::Shape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(incorrectWeightsParams)),
     ConvolutionWIthIncorrectWeightsTransformation::getTestCaseName);
 
@@ -212,7 +206,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConvolutionTransformation,
              ::testing::ValuesIn(netPrecisions),
              ::testing::ValuesIn(shapes),
              ::testing::Values(ov::test::utils::DEVICE_CPU),
-             ::testing::ValuesIn(trasformationParamValues),
              ::testing::ValuesIn(params)),
              ConvolutionTransformation::getTestCaseName);
 }  // namespace convolution3D

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/eliminate_fake_quantize_transformation.cpp

@@ -14,7 +14,6 @@ namespace {
 const std::vector<EliminateFakeQuantizeTransformationTestValues> testValues = {
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { 256ul, {}, { 0.f }, { 255.f / 2.f }, { 0.f }, { 255.f / 2.f }, ov::element::f32 },
@@ -28,7 +27,6 @@ const std::vector<EliminateFakeQuantizeTransformationTestValues> testValues = {
     },
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { 256ul, {}, { 0.f }, { 255.f / 2.f }, { 0.f }, { 255.f / 2.f }, ov::element::f32 },

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/fq_and_avg_pool_transformation.cpp

@@ -15,10 +15,6 @@ const std::vector<ov::element::Type> precisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<ov::builder::subgraph::FakeQuantizeOnData> fakeQuantizes = {
     { 256ul, {}, { 0.f }, { 25.5f }, { 0.f }, { 25.5f } },
 };
@@ -30,7 +26,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FakeQuantizeAndAvgPoolTransformation,
         ::testing::ValuesIn(precisions),
         ::testing::Values(ov::PartialShape({ 1, 32, 72, 48 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(fakeQuantizes)),
     FakeQuantizeAndAvgPoolTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/fq_and_max_pool_transformation.cpp

@@ -15,10 +15,6 @@ const std::vector<ov::element::Type> precisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<ov::builder::subgraph::FakeQuantizeOnData> fakeQuantizes = {
     { 256ul, {}, { 0.f }, { 25.5f }, { 0.f }, { 25.5f } },
 };
@@ -30,7 +26,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FakeQuantizeAndMaxPoolTransformation,
         ::testing::ValuesIn(precisions),
         ::testing::Values(ov::PartialShape({ 1, 32, 72, 48 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(fakeQuantizes)),
     FakeQuantizeAndMaxPoolTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/fq_and_two_output_branches_with_convolution.cpp

@@ -15,10 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<FakeQuantizeAndTwoOutputBranchesWithConvolution> testValues = {
     {
         { 256ul, {}, { 0.f }, { 25.5f }, { 0.f }, { 25.5f } },
@@ -32,7 +28,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FakeQuantizeAndTwoOutputBranchesWithConvolut
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 32, 72, 48 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(testValues)),
     FakeQuantizeAndTwoOutputBranchesWithConvolutionTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/fq_precision_selection_transformation.cpp

@@ -16,10 +16,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<FakeQuantizePrecisionSelectionTransformationTestValues> testValues = {
     {
         { ov::element::u8, ov::element::i8 },
@@ -60,7 +56,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FakeQuantizePrecisionSelectionTransformation
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 32, 72, 48 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(testValues)),
     FakeQuantizePrecisionSelectionTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/fq_transformation.cpp

@@ -16,14 +16,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    // can not be passed to plugin
-    // nGraph: I8 -> FP32 Convert is not supported
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8(),
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<bool> isConvertOnConstants = {
     false,
     true
@@ -90,7 +82,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FakeQuantizeTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 32, 72, 48 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(fakeQuantizeOnDataValues),
         ::testing::ValuesIn(isConvertOnConstants)),
     FakeQuantizeTransformation::getTestCaseName);

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/fq_with_dq_not_optimal_transformation.cpp

@@ -16,10 +16,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f32
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsFactory::createParamsU8I8AndI8(),
-};
-
 const std::vector<FakeQuantizeWithNotOptimalTransformationTestValues> fakeQuantizeOnDataValues = {
     {
         { 256ul, {{ 1, 1, 1, 1 }}, { 0.f }, { 25.5f }, { -128.f }, { 127.f }, ov::element::f32 },
@@ -104,7 +100,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FakeQuantizeWithNotOptimalTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(fakeQuantizeOnDataValues)),
     FakeQuantizeWithNotOptimalTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/fully_connected_transformation.cpp

@@ -35,10 +35,6 @@ const std::vector<FullyConnectedShapes> shapes = {
     },
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams()
-};
-
 const std::vector<FullyConnectedParams> activations = {
     {
         true,  // activation
@@ -75,7 +71,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FullyConnectedTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::ValuesIn(shapes),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn({ov::element::i8/*, ov::element::u8*/}),
         ::testing::ValuesIn(activations),
         ::testing::Values("")),

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/fuse_dequantize_to_fq_transformation.cpp

@@ -15,7 +15,6 @@ const std::vector<FuseDequantizeToFakeQuantizeTransformationTestValues> testValu
     // 1) Multiply
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { },
@@ -27,7 +26,6 @@ const std::vector<FuseDequantizeToFakeQuantizeTransformationTestValues> testValu
     },
     {
         {128, 3},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { },
@@ -40,7 +38,6 @@ const std::vector<FuseDequantizeToFakeQuantizeTransformationTestValues> testValu
     // 1) Multiply by zero
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { },
@@ -53,7 +50,6 @@ const std::vector<FuseDequantizeToFakeQuantizeTransformationTestValues> testValu
     // 1) Subtract + Multiply
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { },
@@ -66,7 +62,6 @@ const std::vector<FuseDequantizeToFakeQuantizeTransformationTestValues> testValu
     // 1) Convert + Subtract + Multiply
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { },
@@ -79,7 +74,6 @@ const std::vector<FuseDequantizeToFakeQuantizeTransformationTestValues> testValu
     // 1) Convert + Subtract + Multiply 2) Add
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { {128}, ov::element::f32 },
@@ -92,7 +86,6 @@ const std::vector<FuseDequantizeToFakeQuantizeTransformationTestValues> testValu
     // issue #40611 for FP32
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             { },
             { },

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/fuse_fq_and_scale_shift_transformation.cpp

@@ -16,10 +16,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<ov::builder::subgraph::FakeQuantizeOnData> fakeQuantizeOnDataValues = {
     { 256ul, {}, { 0.f }, { 2.55f }, { 0.f }, { 2.55f } }
 // TODO: Issue 39810
@@ -38,7 +34,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FuseFakeQuantizeAndScaleShiftTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 9, 9 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(fakeQuantizeOnDataValues)),
     FuseFakeQuantizeAndScaleShiftTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/fuse_multiply_to_fq_transformation.cpp

@@ -13,15 +13,13 @@ namespace {
 const std::vector<FuseMultiplyToFakeQuantizeTransformationTestValues> testValues = {
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             { 256ul, {}, { 0.f }, { 2.55f }, { 0.f }, { 2.55f } },
             { {}, {}, {} },
         }
     },
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             { 256ul, {}, { -1.28f }, { 1.27f }, { 10.f }, { 2.55f } },
             { {}, {}, {} },

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/fuse_subtract_to_fq_transformation.cpp

@@ -13,15 +13,13 @@ namespace {
 const std::vector<FuseSubtractToFakeQuantizeTransformationTestValues> testValues = {
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             { 256ul, {}, { 0.f }, { 2.55f }, { 10.f }, { 255.f } },
             { {}, {}, {} },
         }
     },
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             { 256ul, {}, { -1.28f }, { 1.27f }, { 0.f }, { 255.f } },
             { {}, {}, {} },

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/gather_transformation.cpp

@@ -26,7 +26,6 @@ const std::vector<GatherTransformationTestValues> testValues = {
         {0},
         {0},
         std::int64_t{0},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         ov::element::f32,
         {256, {}, {0.f}, {25.5f}, {12.5f}, {25.5f + 12.5f}}
     },
@@ -37,7 +36,6 @@ const std::vector<GatherTransformationTestValues> testValues = {
         {0},
         {0},
         std::int64_t{0},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         ov::element::f32,
         {
             256,
@@ -55,7 +53,6 @@ const std::vector<GatherTransformationTestValues> testValues = {
         {0},
         {1},
         std::int64_t{0},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         ov::element::f32,
         {
             256,
@@ -73,7 +70,6 @@ const std::vector<GatherTransformationTestValues> testValues = {
         {1, 2},
         {0},
         std::int64_t{0},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         ov::element::f32,
         {256, {}, {0.f}, {25.5f}, {12.5f}, {25.5f + 12.5f}}
     },

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/group_convolution_transformation.cpp

@@ -14,10 +14,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams()
-};
-
 const std::vector<bool> addPrecisionPreserved = { true, false };
 
 const std::vector<std::pair<ov::PartialShape, ov::Shape>> inputShapes = {
@@ -89,7 +85,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, GroupConvolutionTransformation,
      ::testing::Combine(
          ::testing::ValuesIn(netPrecisions),
          ::testing::Values(ov::test::utils::DEVICE_CPU),
-         ::testing::ValuesIn(trasformationParamValues),
          ::testing::ValuesIn(inputShapes),
          ::testing::ValuesIn(params),
          ::testing::ValuesIn(addPrecisionPreserved)),
@@ -140,7 +135,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, GroupConvolutionTransformation,
      ::testing::Combine(
          ::testing::ValuesIn(netPrecisions),
          ::testing::Values(ov::test::utils::DEVICE_CPU),
-         ::testing::ValuesIn(trasformationParamValues),
          ::testing::ValuesIn(inputShapes),
          ::testing::ValuesIn(params),
          ::testing::Values(false)),
@@ -192,7 +186,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, GroupConvolutionTransformation,
      ::testing::Combine(
          ::testing::ValuesIn(netPrecisions),
          ::testing::Values(ov::test::utils::DEVICE_CPU),
-         ::testing::ValuesIn(trasformationParamValues),
          ::testing::ValuesIn(inputShapes),
          ::testing::ValuesIn(params),
          ::testing::Values(false)),
@@ -256,7 +249,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, GroupConvolutionTransformation,
     ::testing::Combine(
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(inputShapes),
         ::testing::ValuesIn(params),
         ::testing::ValuesIn(addPrecisionPreserved)),
@@ -288,7 +280,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, GroupConvolutionTransformation,
     ::testing::Combine(
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(inputShapes),
         ::testing::ValuesIn(params),
         ::testing::ValuesIn(addPrecisionPreserved)),

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/groupconvolution_qdq_transformation.cpp

@@ -17,11 +17,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-};
-
 const std::vector<LayerTestsDefinitions::GroupConvolutionQDqTransformationParam> params = {
     // Actual:
     //
@@ -615,7 +610,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, GroupConvolutionQDqTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::ValuesIn(shapes),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     GroupConvolutionQDqTransformation::getTestCaseName);
 

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/move_fake_quantize_transformation.cpp

@@ -13,10 +13,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(true)
-};
-
 namespace testValues1 {
 
 const std::vector<LayerTestsDefinitions::MoveFakeQuantizeTransformationParam> params = {
@@ -146,7 +142,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, MoveFakeQuantizeTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::ValuesIn(shapes),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn({false, true}),
         ::testing::ValuesIn(params)),
     MoveFakeQuantizeTransformation::getTestCaseName);
@@ -177,7 +172,6 @@ namespace testValues2 {
             ::testing::ValuesIn(netPrecisions),
             ::testing::ValuesIn(shapes),
             ::testing::Values(ov::test::utils::DEVICE_CPU),
-            ::testing::ValuesIn(trasformationParamValues),
             ::testing::ValuesIn({false}),
             ::testing::ValuesIn(params)),
         MoveFakeQuantizeTransformation::getTestCaseName);

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/multiply_to_group_convolution.cpp

@@ -48,16 +48,13 @@ const std::vector<MultiplyToGroupConvolutionTransformationParam> params = {
      "U8",
      true}};
 
-//Comment out the tests because of the transformation is disabled by another WR
-/*
 INSTANTIATE_TEST_SUITE_P(smoke_LPT, MultiplyToGroupConvolutionTransformation,
     ::testing::Combine(
         ::testing::ValuesIn(precisions),
         ::testing::ValuesIn(inputShapes),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
         ::testing::ValuesIn(params)),
     MultiplyToGroupConvolutionTransformation::getTestCaseName);
-*/
 }  // namespace shape4d
 
 namespace shape5d {
@@ -92,15 +89,12 @@ const std::vector<MultiplyToGroupConvolutionTransformationParam> params = {
      "output/GroupConvolution",
      "U8"}};
 
-//Comment out the tests because of the transformation is disabled by another WR
-/*
 INSTANTIATE_TEST_SUITE_P(smoke_LPT, MultiplyToGroupConvolutionTransformation,
      ::testing::Combine(
          ::testing::ValuesIn(precisions),
          ::testing::ValuesIn(inputShapes),
          ::testing::Values(ov::test::utils::DEVICE_CPU),
          ::testing::ValuesIn(params)),
      MultiplyToGroupConvolutionTransformation::getTestCaseName);
-*/
 }  // namespace shape5d
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/output_layers.cpp

@@ -16,18 +16,10 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f16
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsFactory::createParamsI8I8(),
-    // LayerTestsUtils::LayerTransformationParamsFactory::createParamsU8I8()
-};
-
-
 INSTANTIATE_TEST_SUITE_P(smoke_LPT, OutputLayers,
     ::testing::Combine(
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::Shape({ 1, 3, 16, 16 })),
-        ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues)),
+        ::testing::Values(ov::test::utils::DEVICE_CPU)),
     OutputLayers::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/pad_transformation.cpp

@@ -21,10 +21,6 @@ const std::vector<ov::PartialShape> inputShapes = {
     { 4, 3, 16, 16}
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 namespace commonTestCases {
 const std::vector<ov::op::PadMode> padModes = {
     ov::op::PadMode::CONSTANT,
@@ -82,7 +78,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, PadTransformation,
         ::testing::ValuesIn(inputShapes),
         ::testing::ValuesIn(padModes),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     PadTransformation::getTestCaseName);
 } // namespace commonTestCases
@@ -234,7 +229,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, PadTransformation,
         ::testing::ValuesIn(inputShapes),
         ::testing::Values(ov::op::PadMode::CONSTANT),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     PadTransformation::getTestCaseName);
 } // namespace testCasesForConstantMode
@@ -278,7 +272,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, PadTransformation,
         ::testing::ValuesIn(inputShapes),
         ::testing::ValuesIn(modesWithoutConstant),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     PadTransformation::getTestCaseName);
 } // namespace testCasesForOtherModes

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/pull_reshape_through_dequantization.cpp

@@ -14,11 +14,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(true),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-};
-
 const std::vector<PullReshapeThroughDequantizationTestValues> params = {
     {
         ov::element::f32,
@@ -74,7 +69,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, PullReshapeThroughDequantizationTransformati
         ::testing::ValuesIn(netPrecisions),
         ::testing::ValuesIn(inputShapes),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(dequantizationOnWeightElementwiseConstantShapes),
         ::testing::ValuesIn(params)),
     PullReshapeThroughDequantizationTransformation::getTestCaseName);

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/recurrent_cell_transformation.cpp

@@ -13,10 +13,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(true)
-};
-
 namespace testValues1 {
 
 const std::vector<LayerTestsDefinitions::RecurrentCellTransformationParam> params = {
@@ -91,7 +87,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, RecurrentCellTransformation,
         ::testing::ValuesIn(activations_shapes),
         ::testing::ValuesIn(weights_shapes),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn({ true, false }),
         ::testing::ValuesIn(params)),
     RecurrentCellTransformation::getTestCaseName);
@@ -171,7 +166,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, RecurrentCellTransformation,
         ::testing::ValuesIn(activations_shapes),
         ::testing::ValuesIn(weights_shapes),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn({ true, false }),
         ::testing::ValuesIn(params)),
     RecurrentCellTransformation::getTestCaseName);

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/reduce_max_transformation.cpp

@@ -16,10 +16,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-     LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<LayerTestsDefinitions::ReduceMaxTransformationParam> params = {
     {
         { 256ul, ov::Shape{ 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 127.f } },
@@ -108,7 +104,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ReduceMaxTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 10, 10 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ReduceMaxTransformation::getTestCaseName);
 

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/reduce_mean_transformation.cpp

@@ -16,10 +16,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-     LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<LayerTestsDefinitions::ReduceMeanTransformationParam> params = {
     {
         { 256ul, ov::Shape{ 1, 1, 1, 1 }, { 0.f }, { 1.27f }, { 0.f }, { 1.27f } },
@@ -150,7 +146,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ReduceMeanTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 10, 10 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ReduceMeanTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/reduce_min_transformation.cpp

@@ -16,10 +16,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-     LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<LayerTestsDefinitions::ReduceMinTransformationParam> params = {
     {
         { 256ul, ov::Shape{ 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 127.f } },
@@ -108,7 +104,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ReduceMinTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 10, 10 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ReduceMinTransformation::getTestCaseName);
 

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/reduce_sum_transformation.cpp

@@ -16,10 +16,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-     LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<LayerTestsDefinitions::ReduceSumTransformationParam> params = {
     {
         { 256ul, ov::Shape{ 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 127.f } },
@@ -94,7 +90,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ReduceSumTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 10, 10 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ReduceSumTransformation::getTestCaseName);
 

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/reshape_transformation.cpp

@@ -14,10 +14,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams()
-};
-
 const std::vector<ReshapeTransformationParam> params = {
     // 3D -> 4D
     {
@@ -179,7 +175,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ReshapeTransformation,
     ::testing::Combine(
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ReshapeTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/shuffle_channels_transformation.cpp

@@ -19,10 +19,6 @@ const std::vector<ov::PartialShape> inputShapes = {
     { 4, 3, 16, 16 }
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(true),
-};
-
 const std::vector<LayerTestsDefinitions::ShuffleChannelsTransformationParam> params = {
     {
         { 256ul, ov::Shape { 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 25.5f } },
@@ -94,7 +90,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ShuffleChannelsTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::ValuesIn(inputShapes),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ShuffleChannelsTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/slice_transformation.cpp → src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/slice_transformation.cpp

@@ -15,10 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams()
-};
-
 const std::vector<LayerTestsDefinitions::SliceTransformationParam> params = {
     {
         {
@@ -57,7 +53,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, SliceTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 24, 24 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     SliceTransformation::getTestCaseName);
 

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/split_transformation.cpp

@@ -17,13 +17,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<LayerTestsDefinitions::SplitTransformationParam> params = {
     // tensor quantization, split second dimension
     {
@@ -88,7 +81,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, SplitTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     SplitTransformation::getTestCaseName);
 

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/squeeze_transformation.cpp

@@ -15,12 +15,6 @@ namespace {
             ov::element::f32
     };
 
-    const std::vector<LayerTransformation::Params> trasformationParamValues = {
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
-        // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8().setUpdatePrecisions(false),
-        // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8().setUpdatePrecisions(true),
-    };
-
     const std::vector<LayerTestsDefinitions::SqueezeTransformationParam> params = {
         {
             { 256ul, ov::Shape { 1, 1, 1, 1 }, { -12.8f }, { 12.7f }, { -12.8f }, { 12.7f } },
@@ -48,7 +42,6 @@ namespace {
         ::testing::Combine(
             ::testing::ValuesIn(precisions),
             ::testing::Values(ov::test::utils::DEVICE_CPU),
-            ::testing::ValuesIn(trasformationParamValues),
             ::testing::ValuesIn(params)),
         SqueezeTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/strided_slice_transformation.cpp

@@ -16,10 +16,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams()
-};
-
 const std::vector<LayerTestsDefinitions::StridedSliceTransformationParam> params = {
     // channel slice, tensor quantization
     {
@@ -109,7 +105,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, StridedSliceTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 24, 24 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     StridedSliceTransformation::getTestCaseName);
 

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/subtract_transformation.cpp

@@ -16,17 +16,10 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f16
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 INSTANTIATE_TEST_SUITE_P(smoke_LPT, SubtractTransformation,
     ::testing::Combine(
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
-        ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues)),
+        ::testing::Values(ov::test::utils::DEVICE_CPU)),
     SubtractTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/transpose_after_matmul_transformation.cpp

@@ -15,12 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<bool> perTensorValues = { true, false };
 
 const std::vector<bool> transposeChannelDimValues = { true, false };
@@ -30,7 +24,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, TransposeAfterMatMulTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(perTensorValues),
         ::testing::ValuesIn(transposeChannelDimValues)),
     TransposeAfterMatMulTransformation::getTestCaseName);

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/transpose_transformation.cpp

@@ -19,15 +19,13 @@ const std::vector<TransposeTransformationTestValues> testValues = {
     {
         { 1, 1000, 1, 1},
         { 0, 2, 3, 1},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         ov::element::f32,
         {256, {}, {0.f}, {25.5f}, {12.5f}, {25.5f + 12.5f}}
     },
     // U8: per-channel quantization
     {
         { 1, 3, 1, 1},
         { 0, 2, 3, 1},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         ov::element::f32,
         {
             256,
@@ -42,7 +40,6 @@ const std::vector<TransposeTransformationTestValues> testValues = {
     {
         { 1, 1000, 1, 1, 3, 4},
         { 0, 2, 1, 3, 5, 4},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         ov::element::f32,
         {256, {}, {0.f}, {25.5f}, {12.5f}, {25.5f + 12.5f}}
     },

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/unsqueeze_transformation.cpp

@@ -15,12 +15,6 @@ namespace {
         ov::element::f32
     };
 
-    const std::vector<LayerTransformation::Params> trasformationParamValues = {
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
-        // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8().setUpdatePrecisions(false),
-        // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8().setUpdatePrecisions(true),
-    };
-
     const std::vector<LayerTestsDefinitions::UnsqueezeTransformationParam> params = {
         {
             { 256ul, ov::Shape { 1, 1, 1 }, { -12.8f }, { 12.7f }, { -12.8f }, { 12.7f } },
@@ -53,7 +47,6 @@ namespace {
         ::testing::Combine(
             ::testing::ValuesIn(precisions),
             ::testing::Values(ov::test::utils::DEVICE_CPU),
-            ::testing::ValuesIn(trasformationParamValues),
             ::testing::ValuesIn(params)),
         UnsqueezeTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_cpu/tests/functional/shared_tests_instances/low_precision_transformations/x64/variadic_split_transformation.cpp

@@ -17,13 +17,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<LayerTestsDefinitions::VariadicSplitTransformationParam> params{
     // tensor quantization, split second dimension
     {
@@ -94,7 +87,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, VariadicSplitTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_CPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     VariadicSplitTransformation::getTestCaseName);
 

src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp

@@ -306,6 +306,8 @@ std::vector<std::string> disabledTestPatterns() {
         R"(.*NoReshapeAndReshapeDynamic.*CodegenGelu.*)",
         // Issue: 163351
         R"(.*CoreThreadingTestsWithIter.*nightly_AsyncInfer_ShareInput.*)",
+        // This transformation is disabled on CPU
+        R"(.*smoke_LPT.*MultiplyToGroupConvolutionTransformation.*)",
     };
 
     // fp32 floor for bf16 models: conversion issue

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/assign_and_read_value_transformation.cpp

@@ -22,11 +22,6 @@ const std::vector<size_t> opsetVersions = {
     // 6  // not supported on GPU
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-};
-
 const std::vector<LayerTestsDefinitions::AssignAndReadValueTransformationParam> params{
     // u8
     {
@@ -48,7 +43,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, AssignAndReadValueTransformation,
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
         ::testing::ValuesIn(opsetVersions),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     AssignAndReadValueTransformation::getTestCaseName);
 

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/clamp_transformation.cpp

@@ -17,13 +17,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-     LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    //  LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-    //  LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8(),
-    //  LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<LayerTestsDefinitions::ClampTransformationParam> params = {
     // tensor quantization
     {
@@ -81,7 +74,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ClampTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ClampTransformation::getTestCaseName);
 

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/concat_with_child_and_output.cpp

@@ -15,10 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams()
-};
-
 const std::vector<ConcatWithChildAndOutputTransformationParam> testValues = {
     // U8
     {
@@ -47,7 +43,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConcatWithChildAndOutputTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 6, 10, 10 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(testValues),
-        ::testing::ValuesIn(trasformationParamValues)),
+        ::testing::ValuesIn(testValues)),
     ConcatWithChildAndOutputTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/concat_with_different_precision_on_children.cpp

@@ -15,10 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<ConcatWithDifferentChildrenTransformationParam> testValues = {
     // U8
     {
@@ -57,7 +53,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConcatWithDifferentChildrenTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 10, 10 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(testValues),
-        ::testing::ValuesIn(trasformationParamValues)),
+        ::testing::ValuesIn(testValues)),
     ConcatWithDifferentChildrenTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/concat_with_intermediate_transformation.cpp

@@ -15,13 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<bool> transparentIntermediateValues = { true, false };
 const std::vector<bool> multiChannelValues = { /*true,*/ false };
 
@@ -30,7 +23,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConcatWithIntermediateTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(transparentIntermediateValues),
         ::testing::ValuesIn(multiChannelValues)),
     ConcatWithIntermediateTransformation::getTestCaseName);

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/concat_with_neighbors_graph_transformation.cpp

@@ -15,19 +15,11 @@ const std::vector<ov::element::Type> precisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConcatWithNeighborsGraphTransformation,
     ::testing::Combine(
         ::testing::ValuesIn(precisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::Values("convolution_addition_original"),
         ::testing::Values("u8")),
     ConcatWithNeighborsGraphTransformation::getTestCaseName);

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/concat_with_split_transformation.cpp

@@ -15,13 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<ConcatWithSplitTransformationParam> testValues = {
     // U8
     {
@@ -50,7 +43,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConcatWithSplitTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 6, 10, 10 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(testValues),
-        ::testing::ValuesIn(trasformationParamValues)),
+        ::testing::ValuesIn(testValues)),
     ConcatWithSplitTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/convolution_backprop_data_transformation.cpp

@@ -15,10 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(true)
-};
-
 const std::vector<LayerTestsDefinitions::ConvolutionBackpropDataTransformationParam> params = {
     // FQ on weights
     {
@@ -117,7 +113,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT_4D, ConvolutionBackpropDataTransformation,
             ::testing::ValuesIn(inputShapes_4D),
             ::testing::ValuesIn(outputShapes_4D),
             ::testing::Values(ov::test::utils::DEVICE_GPU),
-            ::testing::ValuesIn(trasformationParamValues),
             ::testing::ValuesIn(params)),
     ConvolutionBackpropDataTransformation::getTestCaseName);
 
@@ -152,7 +147,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT_3D, ConvolutionBackpropDataTransformation,
         ::testing::ValuesIn(inputShapes_3D),
         ::testing::ValuesIn(outputShapes_3D),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params_3D)),
     ConvolutionBackpropDataTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/convolution_qdq_transformation.cpp

@@ -16,11 +16,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-};
-
 const std::vector<LayerTestsDefinitions::ConvolutionQDqTransformationParam> params = {
     // Actual:
     //
@@ -297,7 +292,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConvolutionQDqTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::ValuesIn(shapes),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ConvolutionQDqTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/convolution_transformation.cpp

@@ -16,10 +16,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams()
-};
-
 const std::vector<LayerTestsDefinitions::ConvolutionTransformationParam> params = {
     {
         { 256ul, ov::Shape { 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 25.5f } },
@@ -124,7 +120,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConvolutionTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::Shape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ConvolutionTransformation::getTestCaseName);
 
@@ -148,7 +143,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ConvolutionWIthIncorrectWeightsTransformatio
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::Shape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(incorrectWeightsParams)),
     ConvolutionWIthIncorrectWeightsTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/eliminate_fake_quantize_transformation.cpp

@@ -12,7 +12,6 @@ namespace {
 const std::vector<EliminateFakeQuantizeTransformationTestValues> testValues = {
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { 256ul, {}, { 0.f }, { 255.f / 2.f }, { 0.f }, { 255.f / 2.f }, ov::element::f32 },
@@ -26,7 +25,6 @@ const std::vector<EliminateFakeQuantizeTransformationTestValues> testValues = {
     },
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { 256ul, {}, { 0.f }, { 255.f / 2.f }, { 0.f }, { 255.f / 2.f }, ov::element::f32 },

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/fq_and_avg_pool_transformation.cpp

@@ -16,10 +16,6 @@ const std::vector<ov::element::Type> precisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<ov::builder::subgraph::FakeQuantizeOnData> fakeQuantizes = {
     { 256ul, {}, { 0.f }, { 25.5f }, { 0.f }, { 25.5f } },
 };
@@ -31,7 +27,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FakeQuantizeAndAvgPoolTransformation,
         ::testing::ValuesIn(precisions),
         ::testing::Values(ov::PartialShape({ 1, 32, 72, 48 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(fakeQuantizes)),
     FakeQuantizeAndAvgPoolTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/fq_and_max_pool_transformation.cpp

@@ -16,10 +16,6 @@ const std::vector<ov::element::Type> precisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<ov::builder::subgraph::FakeQuantizeOnData> fakeQuantizes = {
     { 256ul, {}, { 0.f }, { 25.5f }, { 0.f }, { 25.5f } },
 };
@@ -31,7 +27,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FakeQuantizeAndMaxPoolTransformation,
         ::testing::ValuesIn(precisions),
         ::testing::Values(ov::PartialShape({ 1, 32, 72, 48 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(fakeQuantizes)),
     FakeQuantizeAndMaxPoolTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/fq_and_two_output_branches_with_convolution.cpp

@@ -16,10 +16,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<FakeQuantizeAndTwoOutputBranchesWithConvolution> testValues = {
     {
         { 256ul, {}, { 0.f }, { 25.5f }, { 0.f }, { 25.5f } },
@@ -33,7 +29,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FakeQuantizeAndTwoOutputBranchesWithConvolut
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 32, 72, 48 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(testValues)),
     FakeQuantizeAndTwoOutputBranchesWithConvolutionTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/fq_precision_selection_transformation.cpp

@@ -17,10 +17,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<FakeQuantizePrecisionSelectionTransformationTestValues> testValues = {
     {
         { ov::element::u8, ov::element::i8 },
@@ -61,7 +57,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FakeQuantizePrecisionSelectionTransformation
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 32, 72, 48 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(testValues)),
     FakeQuantizePrecisionSelectionTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/fq_transformation.cpp

@@ -22,14 +22,6 @@ const std::vector<bool> isConvertOnConstants = {
         true
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    // can not be passed to plugin
-    // nGraph: I8 -> FP32 Convert is not supported
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8(),
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<FakeQuantizeTransformationParam> fakeQuantizeOnDataValues = {
     {
         {256ul, {}, {0.f}, {2.55f}, {0.f}, {2.55f}},
@@ -70,7 +62,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FakeQuantizeTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 32, 72, 48 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(fakeQuantizeOnDataValues),
         ::testing::ValuesIn(isConvertOnConstants)),
     FakeQuantizeTransformation::getTestCaseName);

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/fq_with_dq_not_optimal_transformation.cpp

@@ -17,11 +17,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16,
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsFactory::createParamsU8I8AndI8(),
-    // LayerTestsUtils::LayerTransformationParamsFactory::createParamsU8I8AndI8().setUpdatePrecisions(false),
-};
-
 const std::vector<FakeQuantizeWithNotOptimalTransformationTestValues> fakeQuantizeOnDataValues = {
     {
         { 256ul, {{ 1, 1, 1, 1 }}, { 0.f }, { 25.5f }, { -128.f }, { 127.f }, ov::element::f32 },
@@ -106,7 +101,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FakeQuantizeWithNotOptimalTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(fakeQuantizeOnDataValues)),
     FakeQuantizeWithNotOptimalTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/fully_connected_transformation.cpp

@@ -36,10 +36,6 @@ const std::vector<FullyConnectedShapes> shapes = {
     },
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams()
-};
-
 const std::vector<FullyConnectedParams> activations = {
     {
         true,  // activation
@@ -69,7 +65,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FullyConnectedTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::ValuesIn(shapes),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn({ov::element::i8/*, ov::element::u8*/}),
         ::testing::ValuesIn(activations),
         ::testing::Values("")),

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/fuse_dequantize_to_fq_transformation.cpp

@@ -15,7 +15,6 @@ const std::vector<FuseDequantizeToFakeQuantizeTransformationTestValues> testValu
     // 1) Multiply
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { },
@@ -28,7 +27,6 @@ const std::vector<FuseDequantizeToFakeQuantizeTransformationTestValues> testValu
     // 1) Multiply with different input and output shape
     {
         {128, 3},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { },
@@ -41,7 +39,6 @@ const std::vector<FuseDequantizeToFakeQuantizeTransformationTestValues> testValu
     // 1) Multiply by zero
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { },
@@ -54,7 +51,6 @@ const std::vector<FuseDequantizeToFakeQuantizeTransformationTestValues> testValu
     // 1) Subtract + Multiply
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { },
@@ -67,7 +63,6 @@ const std::vector<FuseDequantizeToFakeQuantizeTransformationTestValues> testValu
     // 1) Convert + Subtract + Multiply
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { },
@@ -80,7 +75,6 @@ const std::vector<FuseDequantizeToFakeQuantizeTransformationTestValues> testValu
     // 1) Convert + Subtract + Multiply 2) Add
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             ov::element::f32,
             { {128}, ov::element::f32 },
@@ -93,7 +87,6 @@ const std::vector<FuseDequantizeToFakeQuantizeTransformationTestValues> testValu
     // issue #40611 for FP32
     {
         {1, 3, 16, 16},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         {
             { },
             { },

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/fuse_fq_and_scale_shift_transformation.cpp

@@ -17,10 +17,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<ov::builder::subgraph::FakeQuantizeOnData> fakeQuantizeOnDataValues = {
     { 256ul, {}, { 0.f }, { 2.55f }, { 0.f }, { 2.55f } },
 // TODO: Issue 39810
@@ -39,7 +35,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, FuseFakeQuantizeAndScaleShiftTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 9, 9 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(fakeQuantizeOnDataValues)),
     FuseFakeQuantizeAndScaleShiftTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/fuse_multiply_to_fq_transformation.cpp

@@ -12,15 +12,13 @@ namespace {
     const std::vector<FuseMultiplyToFakeQuantizeTransformationTestValues> testValues = {
         {
             {1, 3, 16, 16},
-            LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
             {
                 { 256ul, {}, { 0.f }, { 2.55f }, { 0.f }, { 2.55f } },
                 { {}, {}, {} },
             }
         },
         {
             {1, 3, 16, 16},
-            LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
             {
                 { 256ul, {}, { -1.28f }, { 1.27f }, { 10.f }, { 2.55f } },
                 { {}, {}, {} },

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/fuse_subtract_to_fq_transformation.cpp

@@ -12,15 +12,13 @@ namespace {
     const std::vector<FuseSubtractToFakeQuantizeTransformationTestValues> testValues = {
         {
             {1, 3, 16, 16},
-            LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
             {
                 { 256ul, {}, { 0.f }, { 2.55f }, { 10.f }, { 255.f } },
                 { {}, {}, {} },
             }
         },
         {
             {1, 3, 16, 16},
-            LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
             {
                 { 256ul, {}, { -1.28f }, { 1.27f }, { 0.f }, { 255.f } },
                 { {}, {}, {} },

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/gather_transformation.cpp

@@ -27,7 +27,6 @@ const std::vector<GatherTransformationTestValues> testValues = {
         {0},
         {0},
         std::int64_t{0},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         ov::element::f32,
         {256, {}, {0.f}, {25.5f}, {12.5f}, {25.5f + 12.5f}}
     },
@@ -38,7 +37,6 @@ const std::vector<GatherTransformationTestValues> testValues = {
         {0},
         {0},
         std::int64_t{0},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         ov::element::f32,
         {
             256,
@@ -56,7 +54,6 @@ const std::vector<GatherTransformationTestValues> testValues = {
         {1, 2},
         {0},
         std::int64_t{0},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         ov::element::f32,
         {256, {}, {0.f}, {25.5f}, {12.5f}, {25.5f + 12.5f}}
     },

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/group_convolution_transformation.cpp

@@ -15,10 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-};
-
 const std::vector<bool> addPrecisionPreserved = { true, false };
 
 const std::vector<std::pair<ov::PartialShape, ov::Shape>> inputShapes = {
@@ -87,7 +83,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, GroupConvolutionTransformation,
     ::testing::Combine(
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(inputShapes),
         ::testing::ValuesIn(params),
         ::testing::ValuesIn(addPrecisionPreserved)),
@@ -138,7 +133,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, GroupConvolutionTransformation,
      ::testing::Combine(
          ::testing::ValuesIn(netPrecisions),
          ::testing::Values(ov::test::utils::DEVICE_GPU),
-         ::testing::ValuesIn(trasformationParamValues),
          ::testing::ValuesIn(inputShapes),
          ::testing::ValuesIn(params),
          ::testing::Values(false)),
@@ -190,7 +184,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, GroupConvolutionTransformation,
      ::testing::Combine(
          ::testing::ValuesIn(netPrecisions),
          ::testing::Values(ov::test::utils::DEVICE_GPU),
-         ::testing::ValuesIn(trasformationParamValues),
          ::testing::ValuesIn(inputShapes),
          ::testing::ValuesIn(params),
          ::testing::Values(false)),
@@ -232,7 +225,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, GroupConvolutionTransformation,
     ::testing::Combine(
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(inputShapes),
         ::testing::ValuesIn(params),
         ::testing::ValuesIn(addPrecisionPreserved)),

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/groupconvolution_qdq_transformation.cpp

@@ -18,11 +18,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     // ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-};
-
 const std::vector<LayerTestsDefinitions::GroupConvolutionQDqTransformationParam> params = {
     // Actual:
     //
@@ -616,7 +611,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, GroupConvolutionQDqTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::ValuesIn(shapes),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     GroupConvolutionQDqTransformation::getTestCaseName);
 

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/move_fake_quantize_transformation.cpp

@@ -15,10 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-};
-
 const std::vector<LayerTestsDefinitions::MoveFakeQuantizeTransformationParam> params = {
     // without operation
     {
@@ -155,7 +151,6 @@ ::testing::Combine(
     ::testing::ValuesIn(netPrecisions),
     ::testing::ValuesIn(shapes),
     ::testing::Values(ov::test::utils::DEVICE_GPU),
-    ::testing::ValuesIn(trasformationParamValues),
     ::testing::ValuesIn({false, true}),
     ::testing::ValuesIn(params)),
 MoveFakeQuantizeTransformation::getTestCaseName);

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/output_layers.cpp

@@ -15,15 +15,10 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsFactory::createParams()
-};
-
 INSTANTIATE_TEST_SUITE_P(smoke_LPT, OutputLayers,
     ::testing::Combine(
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::Shape({ 1, 3, 16, 16 })),
-        ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues)),
+        ::testing::Values(ov::test::utils::DEVICE_GPU)),
     OutputLayers::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/pad_transformation.cpp

@@ -21,10 +21,6 @@ const std::vector<ov::PartialShape> inputShapes = {
     { 1, 3, 16, 16},
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 namespace commonTestCases {
 
 const std::vector<ov::op::PadMode> padModes = {
@@ -62,7 +58,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, PadTransformation,
         ::testing::ValuesIn(inputShapes),
         ::testing::ValuesIn(padModes),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     PadTransformation::getTestCaseName);
 } // namespace commonTestCases
@@ -94,7 +89,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, PadTransformation,
         ::testing::ValuesIn(inputShapes),
         ::testing::Values(ov::op::PadMode::CONSTANT),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     PadTransformation::getTestCaseName);
 } // namespace testCasesForConstantMode
@@ -122,7 +116,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, PadTransformation,
         ::testing::ValuesIn(inputShapes),
         ::testing::ValuesIn(modesWithoutConstant),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     PadTransformation::getTestCaseName);
 } // namespace testCasesForOtherModes

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/pull_reshape_through_dequantization.cpp

@@ -15,11 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     // ov::element::f16 // TODO: enable f16 test inference (change ngraph function + fp32 to fp16 replacements)
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-};
-
 const std::vector<PullReshapeThroughDequantizationTestValues> params = {
     {
         ov::element::f32,
@@ -75,7 +70,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, PullReshapeThroughDequantizationTransformati
         ::testing::ValuesIn(netPrecisions),
         ::testing::ValuesIn(inputShapes),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(dequantizationOnWeightElementwiseConstantShapes),
         ::testing::ValuesIn(params)),
     PullReshapeThroughDequantizationTransformation::getTestCaseName);

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/recurrent_cell_transformation.cpp

@@ -13,10 +13,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f32,
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(true)
-};
-
 namespace testValues1 {
 
 const std::vector<LayerTestsDefinitions::RecurrentCellTransformationParam> params = {
@@ -91,7 +87,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, RecurrentCellTransformation,
         ::testing::ValuesIn(activations_shapes),
         ::testing::ValuesIn(weights_shapes),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn({ true, false }),
         ::testing::ValuesIn(params)),
     RecurrentCellTransformation::getTestCaseName);
@@ -171,7 +166,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, RecurrentCellTransformation,
         ::testing::ValuesIn(activations_shapes),
         ::testing::ValuesIn(weights_shapes),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn({ true, false }),
         ::testing::ValuesIn(params)),
     RecurrentCellTransformation::getTestCaseName);

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/reduce_max_transformation.cpp

@@ -17,10 +17,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-     LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<LayerTestsDefinitions::ReduceMaxTransformationParam> params = {
     {
         { 256ul, ov::Shape{ 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 127.f } },
@@ -93,7 +89,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ReduceMaxTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 10, 10 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ReduceMaxTransformation::getTestCaseName);
 

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/reduce_mean_transformation.cpp

@@ -17,10 +17,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-     LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<LayerTestsDefinitions::ReduceMeanTransformationParam> params = {
     {
         { 256ul, ov::Shape{ 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 127.f } },
@@ -109,7 +105,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ReduceMeanTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 10, 10 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ReduceMeanTransformation::getTestCaseName);
 

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/reduce_min_transformation.cpp

@@ -17,10 +17,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-     LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<LayerTestsDefinitions::ReduceMinTransformationParam> params = {
     {
         { 256ul, ov::Shape{ 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 127.f } },
@@ -93,7 +89,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ReduceMinTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 10, 10 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ReduceMinTransformation::getTestCaseName);
 

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/reduce_sum_transformation.cpp

@@ -17,10 +17,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-     LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<LayerTestsDefinitions::ReduceSumTransformationParam> params = {
     {
         { 256ul, ov::Shape{ 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 127.f } },
@@ -83,7 +79,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ReduceSumTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 10, 10 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ReduceSumTransformation::getTestCaseName);
 

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/reshape_transformation.cpp

@@ -15,10 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-};
-
 const std::vector<ReshapeTransformationParam> params = {
     // 3D -> 4D
     {
@@ -170,7 +166,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ReshapeTransformation,
     ::testing::Combine(
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ReshapeTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/shuffle_channels_transformation.cpp

@@ -19,10 +19,6 @@ const std::vector<ov::PartialShape> inputShapes = {
     { 1, 3, 16, 16 }
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-};
-
 const std::vector<LayerTestsDefinitions::ShuffleChannelsTransformationParam> params = {
     {
         { 256ul, ov::Shape { 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 25.5f } },
@@ -82,7 +78,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, ShuffleChannelsTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::ValuesIn(inputShapes),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     ShuffleChannelsTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/slice_transformation.cpp

@@ -15,10 +15,6 @@ const std::vector<ov::element::Type> netPrecisions = {
         ov::element::f32
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams()
-};
-
 const std::vector<LayerTestsDefinitions::SliceTransformationParam> params = {
     {
         {
@@ -57,7 +53,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, SliceTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 24, 24 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     SliceTransformation::getTestCaseName);
 

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/split_transformation.cpp

@@ -18,13 +18,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<LayerTestsDefinitions::SplitTransformationParam> params = {
     // tensor quantization, split second dimension
     {
@@ -89,7 +82,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, SplitTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     SplitTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/squeeze_transformation.cpp

@@ -17,12 +17,6 @@ namespace {
     };
 
 
-    const std::vector<LayerTransformation::Params> trasformationParamValues = {
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
-        // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8().setUpdatePrecisions(false),
-        // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8().setUpdatePrecisions(true),
-    };
-
     const std::vector<LayerTestsDefinitions::SqueezeTransformationParam> params = {
         {
             { 256ul, ov::Shape { 1, 1, 1, 1 }, { -12.8f }, { 12.7f }, { -12.8f }, { 12.7f } },
@@ -50,7 +44,6 @@ namespace {
         ::testing::Combine(
             ::testing::ValuesIn(netPrecisions),
             ::testing::Values(ov::test::utils::DEVICE_GPU),
-            ::testing::ValuesIn(trasformationParamValues),
             ::testing::ValuesIn(params)),
         SqueezeTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/strided_slice_transformation.cpp

@@ -17,10 +17,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-};
-
 const std::vector<LayerTestsDefinitions::StridedSliceTransformationParam> params = {
     // channel slice, tensor quantization
     {
@@ -110,7 +106,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, StridedSliceTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 24, 24 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     StridedSliceTransformation::getTestCaseName);
 

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/subtract_transformation.cpp

@@ -16,15 +16,10 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams()
-};
-
 INSTANTIATE_TEST_SUITE_P(smoke_LPT, SubtractTransformation,
     ::testing::Combine(
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
-        ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues)),
+        ::testing::Values(ov::test::utils::DEVICE_GPU)),
     SubtractTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/transpose_after_matmul_transformation.cpp

@@ -16,10 +16,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams()
-};
-
 const std::vector<bool> perTensorValues = { true, false };
 
 const std::vector<bool> transposeChannelDimValues = { true, false };
@@ -29,7 +25,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, TransposeAfterMatMulTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(perTensorValues),
         ::testing::ValuesIn(transposeChannelDimValues)),
     TransposeAfterMatMulTransformation::getTestCaseName);

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/transpose_transformation.cpp

@@ -20,15 +20,13 @@ const std::vector<TransposeTransformationTestValues> testValues = {
     {
         { 1, 1000, 1, 1},
         { 0, 2, 3, 1},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         ov::element::f32,
         {256, {}, {0.f}, {25.5f}, {12.5f}, {25.5f + 12.5f}}
     },
     // U8: per-channel quantization
     {
         { 1, 3, 1, 1},
         { 0, 2, 3, 1},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         ov::element::f32,
         {
             256,
@@ -43,7 +41,6 @@ const std::vector<TransposeTransformationTestValues> testValues = {
     {
         { 1, 1000, 1, 1, 3, 4},
         { 0, 2, 1, 3, 5, 4},
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
         ov::element::f32,
         {256, {}, {0.f}, {25.5f}, {12.5f}, {25.5f + 12.5f}}
     },

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/unsqueeze_transformation.cpp

@@ -17,12 +17,6 @@ namespace {
     };
 
 
-    const std::vector<LayerTransformation::Params> trasformationParamValues = {
-        LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8(),
-        // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8().setUpdatePrecisions(false),
-        // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8().setUpdatePrecisions(true),
-    };
-
     const std::vector<LayerTestsDefinitions::UnsqueezeTransformationParam> params = {
         {
             { 256ul, ov::Shape { 1, 1, 1 }, { -12.8f }, { 12.7f }, { -12.8f }, { 12.7f } },
@@ -55,7 +49,6 @@ namespace {
         ::testing::Combine(
             ::testing::ValuesIn(netPrecisions),
             ::testing::Values(ov::test::utils::DEVICE_GPU),
-            ::testing::ValuesIn(trasformationParamValues),
             ::testing::ValuesIn(params)),
         UnsqueezeTransformation::getTestCaseName);
 }  // namespace

src/plugins/intel_gpu/tests/functional/shared_tests_instances/low_precision_transformations/variadic_split_transformation.cpp

@@ -18,13 +18,6 @@ const std::vector<ov::element::Type> netPrecisions = {
     ov::element::f16
 };
 
-const std::vector<ov::pass::low_precision::LayerTransformation::Params> trasformationParamValues = {
-    LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParams().setUpdatePrecisions(false),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsI8I8(),
-    // LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8()
-};
-
 const std::vector<LayerTestsDefinitions::VariadicSplitTransformationParam> params{
     // tensor quantization, split second dimension
     {
@@ -95,7 +88,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_LPT, VariadicSplitTransformation,
         ::testing::ValuesIn(netPrecisions),
         ::testing::Values(ov::PartialShape({ 1, 3, 16, 16 })),
         ::testing::Values(ov::test::utils::DEVICE_GPU),
-        ::testing::ValuesIn(trasformationParamValues),
         ::testing::ValuesIn(params)),
     VariadicSplitTransformation::getTestCaseName);
 

src/tests/functional/plugin/shared/include/low_precision_transformations/assign_and_read_value_transformation.hpp

@@ -14,14 +14,13 @@ class AssignAndReadValueTransformationParam {
     ov::builder::subgraph::FakeQuantizeOnData fakeQuantize;
 };
 
-typedef std::tuple <
-    ov::element::Type,         // input precision
-    ov::PartialShape,          // input shape
-    size_t,                        // opset version
-    std::string,                   // device
-    ov::pass::low_precision::LayerTransformation::Params, // transformation params
-    AssignAndReadValueTransformationParam       // test params
-> AssignAndReadValueTransformationParams;
+typedef std::tuple<ov::element::Type,                     // input precision
+                   ov::PartialShape,                      // input shape
+                   size_t,                                // opset version
+                   std::string,                           // device
+                   AssignAndReadValueTransformationParam  // test params
+                   >
+    AssignAndReadValueTransformationParams;
 
 class AssignAndReadValueTransformation :
     public testing::WithParamInterface<AssignAndReadValueTransformationParams>,

src/tests/functional/plugin/shared/include/low_precision_transformations/clamp_transformation.hpp

@@ -21,7 +21,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ClampTransformationParam
 > ClampTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/concat_with_child_and_output.hpp

@@ -17,13 +17,11 @@ class ConcatWithChildAndOutputTransformationParam {
     ov::builder::subgraph::FakeQuantizeOnData fqOnData2;
 };
 
-typedef std::tuple<
-    ov::element::Type,
-    ov::PartialShape,
-    std::string, // target device: CPU, GPU
-    ConcatWithChildAndOutputTransformationParam,
-    ov::pass::low_precision::LayerTransformation::Params // transformation parameters
-> ConcatWithChildAndOutputTransformationParams;
+typedef std::tuple<ov::element::Type,
+                   ov::PartialShape,
+                   std::string,
+                   ConcatWithChildAndOutputTransformationParam>
+    ConcatWithChildAndOutputTransformationParams;
 
 class ConcatWithChildAndOutputTransformation :
     public testing::WithParamInterface<ConcatWithChildAndOutputTransformationParams>,

src/tests/functional/plugin/shared/include/low_precision_transformations/concat_with_different_precision_on_children.hpp

@@ -18,13 +18,11 @@ class ConcatWithDifferentChildrenTransformationParam {
     ov::builder::subgraph::FakeQuantizeOnData fqOnData2;
 };
 
-typedef std::tuple<
-    ov::element::Type,
-    ov::PartialShape,
-    std::string, // target device: CPU, GPU
-    ConcatWithDifferentChildrenTransformationParam,
-    ov::pass::low_precision::LayerTransformation::Params // transformation parameters
-    > ConcatWithDifferentChildrenTransformationParams;
+typedef std::tuple<ov::element::Type,
+                   ov::PartialShape,
+                   std::string,  // target device: CPU, GPU
+                   ConcatWithDifferentChildrenTransformationParam>
+    ConcatWithDifferentChildrenTransformationParams;
 
 class ConcatWithDifferentChildrenTransformation :
     public testing::WithParamInterface<ConcatWithDifferentChildrenTransformationParams>,

src/tests/functional/plugin/shared/include/low_precision_transformations/concat_with_intermediate_transformation.hpp

@@ -15,7 +15,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string, // target device: CPU, GPU
-    ov::pass::low_precision::LayerTransformation::Params, // transformation parameters
     bool, // transparent intermediate
     // multichannel
     bool> ConcatWithIntermediateTransformationParams;

src/tests/functional/plugin/shared/include/low_precision_transformations/concat_with_neighbors_graph_transformation.hpp

@@ -15,7 +15,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     std::string,
     std::string> ConcatNeighboringGraphTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/concat_with_split_transformation.hpp

@@ -21,8 +21,7 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ConcatWithSplitTransformationParam,
-    ov::pass::low_precision::LayerTransformation::Params> ConcatWithSplitTransformationParams;
+    ConcatWithSplitTransformationParam> ConcatWithSplitTransformationParams;
 
 class ConcatWithSplitTransformation :
     public testing::WithParamInterface<ConcatWithSplitTransformationParams>,

src/tests/functional/plugin/shared/include/low_precision_transformations/convolution_backprop_data_transformation.hpp

@@ -41,14 +41,12 @@ class ConvolutionBackpropDataTransformationParam {
         layerName(std::move(layerName)), expectedKernelType(std::move(expectedKernelType)) {}
 };
 
-typedef std::tuple<
-    ov::element::Type, // netPrecision
-    std::pair<ov::PartialShape, bool>, // input shape and shape support flag
-    ov::Shape,         // outputShape
-    std::string,           // targetDevice
-    ov::pass::low_precision::LayerTransformation::Params,
-    ConvolutionBackpropDataTransformationParam
-> ConvolutionBackpropDataTransformationParams;
+typedef std::tuple<ov::element::Type,                  // netPrecision
+                   std::pair<ov::PartialShape, bool>,  // input shape and shape support flag
+                   ov::Shape,                          // outputShape
+                   std::string,                        // targetDevice
+                   ConvolutionBackpropDataTransformationParam>
+    ConvolutionBackpropDataTransformationParams;
 
 class ConvolutionBackpropDataTransformation :
     public testing::WithParamInterface<ConvolutionBackpropDataTransformationParams>,

src/tests/functional/plugin/shared/include/low_precision_transformations/convolution_qdq_transformation.hpp

@@ -49,7 +49,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ConvolutionQDqTransformationParam
 > ConvolutionQDqTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/convolution_transformation.hpp

@@ -27,7 +27,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::Shape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ConvolutionTransformationParam
 > ConvolutionTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/convolution_with_incorrect_weights.hpp

@@ -24,7 +24,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::Shape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ConvolutionWIthIncorrectWeightsParam
 > ConvolutionWIthIncorrectWeightsParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/eliminate_fake_quantize_transformation.hpp

@@ -31,7 +31,6 @@ class EliminateFakeQuantizeTransformationTestValues {
     };
 
     ov::PartialShape inputShape;
-    ov::pass::low_precision::LayerTransformation::Params params;
     Actual actual;
     Expected expected;
 };

src/tests/functional/plugin/shared/include/low_precision_transformations/fake_quantize_and_avg_pool_transformation.hpp

@@ -16,7 +16,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ov::builder::subgraph::FakeQuantizeOnData> FakeQuantizeAndAvgPoolTransformationParams;
 
 class FakeQuantizeAndAvgPoolTransformation :

src/tests/functional/plugin/shared/include/low_precision_transformations/fake_quantize_and_max_pool_transformation.hpp

@@ -16,7 +16,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ov::builder::subgraph::FakeQuantizeOnData> FakeQuantizeAndMaxPoolTransformationParams;
 
 class FakeQuantizeAndMaxPoolTransformation :

src/tests/functional/plugin/shared/include/low_precision_transformations/fake_quantize_and_two_output_branches_with_convolution.hpp

@@ -24,7 +24,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     FakeQuantizeAndTwoOutputBranchesWithConvolution
 > FakeQuantizeAndTwoOutputBranchesWithConvolutionParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/fake_quantize_precision_selection_transformation.hpp

@@ -52,7 +52,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     FakeQuantizePrecisionSelectionTransformationTestValues> FakeQuantizeTransformationParams;
 
 class FakeQuantizePrecisionSelectionTransformation :

src/tests/functional/plugin/shared/include/low_precision_transformations/fake_quantize_transformation.hpp

@@ -22,7 +22,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     FakeQuantizeTransformationParam,
     bool> FakeQuantizeTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/fake_quantize_with_dq_not_optimal_transformation.hpp

@@ -52,7 +52,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     FakeQuantizeWithNotOptimalTransformationTestValues> FakeQuantizeTransformationParams;
 
 class FakeQuantizeWithNotOptimalTransformation :

src/tests/functional/plugin/shared/include/low_precision_transformations/fully_connected_transformation.hpp

@@ -29,7 +29,6 @@ typedef std::tuple<
     ov::element::Type,
     FullyConnectedShapes,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ov::element::Type,
     FullyConnectedParams,
     std::string> FullyConnectedTransformationParams;

src/tests/functional/plugin/shared/include/low_precision_transformations/fuse_dequantize_to_fake_quantize_transformation.hpp

@@ -26,7 +26,6 @@ class FuseDequantizeToFakeQuantizeTransformationTestValues {
     };
 
     ov::PartialShape inputShape;
-    ov::pass::low_precision::LayerTransformation::Params params;
     Actual actual;
 };
 

src/tests/functional/plugin/shared/include/low_precision_transformations/fuse_fake_quantize_and_scale_shift_transformation.hpp

@@ -15,7 +15,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ov::builder::subgraph::FakeQuantizeOnData> FuseFakeQuantizeAndScaleShiftTransformationParams;
 
 class FuseFakeQuantizeAndScaleShiftTransformation :

src/tests/functional/plugin/shared/include/low_precision_transformations/fuse_multiply_to_fake_quantize_transformation.hpp

@@ -22,7 +22,6 @@ class FuseMultiplyToFakeQuantizeTransformationTestValues {
     };
 
     ov::PartialShape inputShape;
-    ov::pass::low_precision::LayerTransformation::Params params;
     Actual actual;
 };
 

src/tests/functional/plugin/shared/include/low_precision_transformations/fuse_subtract_to_fake_quantize_transformation.hpp

@@ -22,7 +22,6 @@ class FuseSubtractToFakeQuantizeTransformationTestValues {
     };
 
     ov::PartialShape inputShape;
-    ov::pass::low_precision::LayerTransformation::Params params;
     Actual actual;
 };
 

src/tests/functional/plugin/shared/include/low_precision_transformations/gather_transformation.hpp

@@ -19,7 +19,6 @@ class GatherTransformationTestValues {
     std::vector<int> gatherIndicesValues;
     std::vector<int> axis;
     int64_t batch_dims;
-    ov::pass::low_precision::LayerTransformation::Params params;
     ov::element::Type precisionBeforeFq;
     ov::builder::subgraph::FakeQuantizeOnData fqOnData;
 };

src/tests/functional/plugin/shared/include/low_precision_transformations/group_convolution_transformation.hpp

@@ -43,7 +43,6 @@ class GroupConvolutionTransformationParam {
 typedef std::tuple<
     ov::element::Type,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     std::pair<ov::PartialShape, ov::Shape>,
     GroupConvolutionTransformationParam,
     bool // add precision preserved operation

src/tests/functional/plugin/shared/include/low_precision_transformations/groupconvolution_qdq_transformation.hpp

@@ -53,7 +53,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     GroupConvolutionQDqTransformationParam
 > GroupConvolutionQDqTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/move_fake_quantize_transformation.hpp

@@ -33,7 +33,6 @@ typedef std::tuple <
     ov::element::Type,
     std::vector<ov::PartialShape>,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     bool,
     MoveFakeQuantizeTransformationParam
 > MoveFakeQuantizeTransformationParams;

src/tests/functional/plugin/shared/include/low_precision_transformations/output_layers.hpp

@@ -11,11 +11,13 @@
 
 namespace LayerTestsDefinitions {
 
+typedef std::tuple<ov::element::Type, ov::Shape, std::string> LayerTransformationParams;
+
 class OutputLayers :
-    public testing::WithParamInterface<LayerTestsUtils::LayerTransformationParams>,
+    public testing::WithParamInterface<LayerTransformationParams>,
     public LayerTestsUtils::LayerTransformation {
 public:
-    static std::string getTestCaseName(const testing::TestParamInfo<LayerTestsUtils::LayerTransformationParams>& obj);
+    static std::string getTestCaseName(const testing::TestParamInfo<LayerTransformationParams>& obj);
 
 protected:
     void SetUp() override;

src/tests/functional/plugin/shared/include/low_precision_transformations/pad_transformation.hpp

@@ -23,7 +23,6 @@ typedef std::tuple<
     ov::PartialShape,
     ov::op::PadMode,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     PadTransformationParam
 > PadTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/pull_reshape_through_dequantization_transformation.hpp

@@ -38,7 +38,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ov::Shape,
     PullReshapeThroughDequantizationTestValues> PullReshapeThroughDequantizationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/recurrent_cell_transformation.hpp

@@ -41,7 +41,6 @@ typedef std::tuple<
     std::vector<ov::PartialShape>,
     std::vector<ov::Shape>,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     bool, // use precision transparent operations
     RecurrentCellTransformationParam
 >RecurrentCellTransformationParams;

src/tests/functional/plugin/shared/include/low_precision_transformations/reduce_max_transformation.hpp

@@ -22,7 +22,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ReduceMaxTransformationParam
 > ReduceMaxTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/reduce_mean_transformation.hpp

@@ -34,7 +34,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ReduceMeanTransformationParam
 > ReduceMeanTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/reduce_min_transformation.hpp

@@ -22,7 +22,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ReduceMinTransformationParam
 > ReduceMinTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/reduce_sum_transformation.hpp

@@ -22,7 +22,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ReduceSumTransformationParam
 > ReduceSumTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/reshape_transformation.hpp

@@ -25,7 +25,6 @@ class ReshapeTransformationParam {
 typedef std::tuple<
     ov::element::Type,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ReshapeTransformationParam
 > ReshapeTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/shuffle_channels_transformation.hpp

@@ -25,7 +25,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     ShuffleChannelsTransformationParam
 > ShuffleChannelsTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/slice_transformation.hpp

@@ -23,7 +23,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     SliceTransformationParam
 > SliceTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/split_transformation.hpp

@@ -19,7 +19,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     SplitTransformationParam
 > SplitTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/squeeze_transformation.hpp

@@ -24,7 +24,6 @@ std::string stringifySqueezeArgs(const std::vector<float>& axes);
 typedef std::tuple<
     ov::element::Type,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     SqueezeTransformationParam
 > SqueezeTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/strided_slice_transformation.hpp

@@ -26,7 +26,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     StridedSliceTransformationParam
 > StridedSliceTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/subtract_transformation.hpp

@@ -14,8 +14,7 @@ namespace LayerTestsDefinitions {
 typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
-    std::string,
-    ov::pass::low_precision::LayerTransformation::Params
+    std::string
 > SubtractTransformationParams;
 
 class SubtractTransformation :

src/tests/functional/plugin/shared/include/low_precision_transformations/transpose_after_matmul_transformation.hpp

@@ -15,7 +15,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     bool,
     bool> TransposeAfterMatMulTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/transpose_transformation.hpp

@@ -16,7 +16,6 @@ class TransposeTransformationTestValues {
 public:
     ov::PartialShape inputShape;
     std::vector<int> transposeConstValues;
-    ov::pass::low_precision::LayerTransformation::Params params;
     ov::element::Type precisionBeforeFq;
     ov::builder::subgraph::FakeQuantizeOnData fqOnData;
 };

src/tests/functional/plugin/shared/include/low_precision_transformations/unsqueeze_transformation.hpp

@@ -22,7 +22,6 @@ class UnsqueezeTransformationParam {
 typedef std::tuple<
     ov::element::Type,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     UnsqueezeTransformationParam
 > UnsqueezeTransformationParams;
 

src/tests/functional/plugin/shared/include/low_precision_transformations/variadic_split_transformation.hpp

@@ -19,7 +19,6 @@ typedef std::tuple<
     ov::element::Type,
     ov::PartialShape,
     std::string,
-    ov::pass::low_precision::LayerTransformation::Params,
     VariadicSplitTransformationParam
 > VariadicSplitTransformationParams;
 

src/tests/functional/plugin/shared/src/low_precision_transformations/add_transformation.cpp

@@ -15,15 +15,9 @@
 namespace LayerTestsDefinitions {
 
 std::string AddTransformation::getTestCaseName(const testing::TestParamInfo< AddTransformationParams>& obj) {
-    ov::element::Type netPrecision;
-    ov::PartialShape inputShapes;
-    std::string targetDevice;
-    auto params = LayerTestsUtils::LayerTransformationParamsNGraphFactory::createParamsU8I8();
-    AddTestValues param;
-    std::tie(netPrecision, inputShapes, targetDevice, param) = obj.param;
-
+    auto [netPrecision, inputShapes, targetDevice, param] = obj.param;
     std::ostringstream result;
-    result << get_test_case_name_by_params(netPrecision, inputShapes, targetDevice, params) <<
+    result << get_test_case_name_by_params(netPrecision, inputShapes, targetDevice) <<
            (param.broadcast ? "_broadcast" : "");
     for (const auto& elem : param.precisionOnActivations) {
         result << "_" << elem << "_";
@@ -51,10 +45,8 @@ std::string AddTransformation::getTestCaseName(const testing::TestParamInfo< Add
 }
 
 void AddTransformation::SetUp() {
-    ov::element::Type precision;
-    ov::PartialShape inputShape;
-    AddTestValues param;
-    std::tie(precision, inputShape, targetDevice, param) = this->GetParam();
+    auto [precision, inputShape, device, param] = this->GetParam();
+    targetDevice = device;
 
     ov::PartialShape inputShape2 = inputShape;
     if (param.broadcast) {