[core] Deprecate undefined type and use dynamic where possible

docs/articles_en/assets/snippets/ov_dynamic_shapes.c

@@ -148,7 +148,7 @@ ov_compiled_model_create_infer_request(compiled_model, &infer_request);
 
 //! [ov_dynamic_shapes:set_input_tensor]
 ov_output_const_port_t* input_port = NULL;
-ov_element_type_e type = UNDEFINED;
+ov_element_type_e type = DYNAMIC;
 ov_shape_t input_shape_1;
 ov_tensor_t* input_tensor_1 = NULL;
 ov_tensor_t* output_tensor = NULL;

samples/cpp/benchmark_app/main.cpp

@@ -529,7 +529,7 @@ int main(int argc, char* argv[]) {
         if (result != config.end())
             device_config = result->second;
         size_t batchSize = FLAGS_b;
-        ov::element::Type type = ov::element::undefined;
+        ov::element::Type type = ov::element::dynamic;
         std::string topology_name = "";
         std::vector<benchmark_app::InputsInfo> app_inputs_info;
         std::string output_name;
@@ -660,14 +660,14 @@ int main(int argc, char* argv[]) {
                                         std::const_pointer_cast<const ov::Model>(model)->outputs());
             }
 
-            const auto input_precision = FLAGS_ip.empty() ? ov::element::undefined : getPrecision2(FLAGS_ip);
-            const auto output_precision = FLAGS_op.empty() ? ov::element::undefined : getPrecision2(FLAGS_op);
+            const auto input_precision = FLAGS_ip.empty() ? ov::element::dynamic : getPrecision2(FLAGS_ip);
+            const auto output_precision = FLAGS_op.empty() ? ov::element::dynamic : getPrecision2(FLAGS_op);
 
             const auto& inputs = model->inputs();
             for (size_t i = 0; i < inputs.size(); i++) {
                 const auto& item = inputs[i];
-                auto iop_precision = ov::element::undefined;
-                auto type_to_set = ov::element::undefined;
+                auto iop_precision = ov::element::dynamic;
+                auto type_to_set = ov::element::dynamic;
                 std::string name;
                 try {
                     // Some tensors might have no names, get_any_name will throw exception in that case.
@@ -676,18 +676,17 @@ int main(int argc, char* argv[]) {
                     iop_precision = getPrecision2(user_precisions_map.at(item.get_any_name()));
                 } catch (...) {
                 }
-
-                if (iop_precision != ov::element::undefined) {
+                if (iop_precision != ov::element::dynamic) {
                     type_to_set = iop_precision;
-                } else if (input_precision != ov::element::undefined) {
+                } else if (input_precision != ov::element::dynamic) {
                     type_to_set = input_precision;
                 } else if (!name.empty() && app_inputs_info[0].at(name).is_image()) {
                     // image input, set U8
                     type_to_set = ov::element::u8;
                 }
 
                 auto& in = preproc.input(item.get_any_name());
-                if (type_to_set != ov::element::undefined) {
+                if (type_to_set != ov::element::dynamic) {
                     in.tensor().set_element_type(type_to_set);
 
                     if (!name.empty()) {
@@ -707,17 +706,16 @@ int main(int argc, char* argv[]) {
             const auto& outs = model->outputs();
             for (size_t i = 0; i < outs.size(); i++) {
                 const auto& item = outs[i];
-                auto iop_precision = ov::element::undefined;
+                auto iop_precision = ov::element::dynamic;
                 try {
                     // Some tensors might have no names, get_any_name will throw exception in that case.
                     // -iop option will not work for those tensors.
                     iop_precision = getPrecision2(user_precisions_map.at(item.get_any_name()));
                 } catch (...) {
                 }
-
-                if (iop_precision != ov::element::undefined) {
+                if (iop_precision != ov::element::dynamic) {
                     preproc.output(i).tensor().set_element_type(iop_precision);
-                } else if (output_precision != ov::element::undefined) {
+                } else if (output_precision != ov::element::dynamic) {
                     preproc.output(i).tensor().set_element_type(output_precision);
                 }
             }

src/bindings/c/include/openvino/c/ov_common.h

@@ -169,33 +169,33 @@ typedef enum {
  * src/core/include/openvino/core/type/element_type.hpp
  */
 typedef enum {
-    UNDEFINED = 0U,  //!< Undefined element type
-    DYNAMIC,         //!< Dynamic element type
-    BOOLEAN,         //!< boolean element type
-    BF16,            //!< bf16 element type
-    F16,             //!< f16 element type
-    F32,             //!< f32 element type
-    F64,             //!< f64 element type
-    I4,              //!< i4 element type
-    I8,              //!< i8 element type
-    I16,             //!< i16 element type
-    I32,             //!< i32 element type
-    I64,             //!< i64 element type
-    U1,              //!< binary element type
-    U2,              //!< u2 element type
-    U3,              //!< u3 element type
-    U4,              //!< u4 element type
-    U6,              //!< u6 element type
-    U8,              //!< u8 element type
-    U16,             //!< u16 element type
-    U32,             //!< u32 element type
-    U64,             //!< u64 element type
-    NF4,             //!< nf4 element type
-    F8E4M3,          //!< f8e4m3 element type
-    F8E5M3,          //!< f8e5m2 element type
-    STRING,          //!< string element type
-    F4E2M1,          //!< f4e2m1 element type
-    F8E8M0,          //!< f8e8m0 element type
+    UNDEFINED = 0U,         //!< Undefined element type
+    DYNAMIC = UNDEFINED,    //!< Dynamic element type
+    BOOLEAN,                //!< boolean element type
+    BF16,                   //!< bf16 element type
+    F16,                    //!< f16 element type
+    F32,                    //!< f32 element type
+    F64,                    //!< f64 element type
+    I4,                     //!< i4 element type
+    I8,                     //!< i8 element type
+    I16,                    //!< i16 element type
+    I32,                    //!< i32 element type
+    I64,                    //!< i64 element type
+    U1,                     //!< binary element type
+    U2,                     //!< u2 element type
+    U3,                     //!< u3 element type
+    U4,                     //!< u4 element type
+    U6,                     //!< u6 element type
+    U8,                     //!< u8 element type
+    U16,                    //!< u16 element type
+    U32,                    //!< u32 element type
+    U64,                    //!< u64 element type
+    NF4,                    //!< nf4 element type
+    F8E4M3,                 //!< f8e4m3 element type
+    F8E5M3,                 //!< f8e5m2 element type
+    STRING,                 //!< string element type
+    F4E2M1,                 //!< f4e2m1 element type
+    F8E8M0,                 //!< f8e8m0 element type
 } ov_element_type_e;
 
 /**

src/bindings/c/src/ov_tensor.cpp

@@ -6,7 +6,7 @@
 #include "common.h"
 
 const std::map<ov_element_type_e, ov::element::Type> element_type_map = {
-    {ov_element_type_e::UNDEFINED, ov::element::undefined},
+    {ov_element_type_e::UNDEFINED, ov::element::dynamic},
     {ov_element_type_e::DYNAMIC, ov::element::dynamic},
     {ov_element_type_e::BOOLEAN, ov::element::boolean},
     {ov_element_type_e::BF16, ov::element::bf16},

src/bindings/python/src/openvino/frontend/tensorflow/node_decoder.py

@@ -20,7 +20,7 @@ def tf_type_to_ov_type(tf_type_int):
     try:
         ret_type = Type(numpy_type)
     except:
-        ret_type = Type.undefined
+        ret_type = Type.dynamic
     return ret_type
 
 
@@ -169,7 +169,7 @@ def get_attribute(self, name):
                         return OVAny(Type.dynamic)
                     return OVAny(tf_type_to_ov_type(variable_value.dtype))
                 else:
-                    return OVAny(Type.undefined)
+                    return OVAny(Type.dynamic)
             return OVAny(tf_type_to_ov_type(type_num))
 
         if name == "value":

src/bindings/python/src/pyopenvino/core/common.cpp

@@ -510,8 +510,7 @@ ov::Tensor tensor_from_pointer(py::array& array, const ov::Shape& shape, const o
     if (type_helpers::get_ov_type(array) == ov::element::string) {
         OPENVINO_THROW("SHARED MEMORY MODE FOR THIS TENSOR IS NOT APPLICABLE! String types can be only copied.");
     }
-
-    auto element_type = (type == ov::element::undefined) ? Common::type_helpers::get_ov_type(array) : type;
+    auto element_type = (type == ov::element::dynamic) ? Common::type_helpers::get_ov_type(array) : type;
 
     if (array_helpers::is_contiguous(array)) {
         return ov::Tensor(element_type, shape, const_cast<void*>(array.data(0)), {});

src/bindings/python/src/pyopenvino/core/tensor.cpp

@@ -42,7 +42,7 @@ void regclass_Tensor(py::module m) {
             }),
             py::arg("array"),
             py::arg("shape"),
-            py::arg("type") = ov::element::undefined,
+            py::arg("type") = ov::element::dynamic,
             py::keep_alive<1, 2>(),
             R"(
                 Another Tensor's special constructor.
@@ -76,7 +76,7 @@ void regclass_Tensor(py::module m) {
             }),
             py::arg("array"),
             py::arg("shape"),
-            py::arg("type") = ov::element::undefined,
+            py::arg("type") = ov::element::dynamic,
             py::keep_alive<1, 2>(),
             R"(
                  Another Tensor's special constructor.

src/bindings/python/src/pyopenvino/graph/preprocess/pre_post_process.cpp

@@ -93,7 +93,7 @@ static void regclass_graph_PreProcessSteps(py::module m) {
         [](ov::preprocess::PreProcessSteps& self, ov::element::Type type = {}) {
             return &self.convert_element_type(type);
         },
-        py::arg_v("type", ov::element::undefined, "openvino.Type.undefined"),
+        py::arg_v("type", ov::element::dynamic, "openvino.Type.dynamic"),
         R"(
             Converts input tensor element type to specified type.
             Input tensor must have openvino.Type data type.
@@ -239,7 +239,7 @@ static void regclass_graph_PostProcessSteps(py::module m) {
         [](ov::preprocess::PostProcessSteps& self, ov::element::Type type = {}) {
             return &self.convert_element_type(type);
         },
-        py::arg_v("type", ov::element::undefined, "openvino.Type.undefined"),
+        py::arg_v("type", ov::element::dynamic, "openvino.Type.dynamic"),
         R"(
             Converts tensor element type to specified type.
             Tensor must have openvino.Type data type.

src/bindings/python/src/pyopenvino/graph/types/element_type.cpp

@@ -31,7 +31,7 @@ void regclass_graph_Type(py::module m) {
             :rtype: ov.Type
         )");
 
-    type.attr("undefined") = ov::element::undefined;
+    type.attr("undefined") = ov::element::dynamic;
     type.attr("dynamic") = ov::element::dynamic;
     type.attr("boolean") = ov::element::boolean;
     type.attr("f16") = ov::element::f16;

src/bindings/python/tests/test_runtime/test_type.py

@@ -92,25 +92,17 @@ def test_basic_ovtypes(ovtype,
 
 def test_undefined_ovtype():
     ov_type = Type.undefined
-    assert ov_type.is_static() is True
-    assert ov_type.is_dynamic() is False
+    assert ov_type.is_static() is False
+    assert ov_type.is_dynamic() is True
     assert ov_type.is_real() is False
-    assert ov_type.real is False
     assert ov_type.is_integral() is True
-    assert ov_type.integral is True
     assert ov_type.is_signed() is False
-    assert ov_type.signed is False
     assert ov_type.is_quantized() is False
-    assert ov_type.quantized is False
-    assert ov_type.get_type_name() == "undefined"
-    assert ov_type.type_name == "undefined"
-    assert ov_type.get_size() == 0
+    assert ov_type.get_type_name() == "dynamic"
     assert ov_type.size == 0
-
-    # Note: might depend on the system
-    import sys
-    assert ov_type.bitwidth == sys.maxsize * 2 + 1
-    assert ov_type.get_bitwidth() == sys.maxsize * 2 + 1
+    assert ov_type.get_size() == 0
+    assert ov_type.bitwidth == 0
+    assert ov_type.get_bitwidth() == 0
 
 
 def test_dynamic_ov_type():

src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp

@@ -32,7 +32,7 @@ namespace precision_set {
 
 class LP_TRANSFORMATIONS_API DataPrecision {
 public:
-    DataPrecision() : precision(element::undefined), min(0.f), max(0.f), hasZeroPoint(false) {}
+    DataPrecision() : precision(element::dynamic), min(0.f), max(0.f), hasZeroPoint(false) {}
 
     explicit DataPrecision(const element::Type& precision) {
         this->precision = precision;
@@ -48,10 +48,9 @@ class LP_TRANSFORMATIONS_API DataPrecision {
             hasZeroPoint(hasZeroPoint) {}
 
     bool empty() const noexcept {
-        assert(
-            ((precision == element::undefined) && (min == 0.f) && (max == 0.f) && (!hasZeroPoint)) ||
-            ((precision != element::undefined) && (max != 0.f)));
-        return (precision == element::undefined) && (min == 0.f) && (max == 0.f) && (!hasZeroPoint);
+        assert(((precision == element::dynamic) && (min == 0.f) && (max == 0.f) && (!hasZeroPoint)) ||
+               ((precision != element::dynamic) && (max != 0.f)));
+        return (precision == element::dynamic) && (min == 0.f) && (max == 0.f) && (!hasZeroPoint);
     }
 
     static bool isSupported(const element::Type& precision) {

src/common/low_precision_transformations/include/low_precision/network_helper.hpp

@@ -186,9 +186,8 @@ class LP_TRANSFORMATIONS_API NetworkHelper {
 
     static size_t getParentOutputIndex(const std::shared_ptr<ov::Node>& parent, const std::shared_ptr<ov::Node>& child);
 
-    static FakeQuantizeDequantizationValues createEmptyValues(
-        const FakeQuantizeDequantization& dequantization,
-        const element::Type& precision = element::undefined);
+    static FakeQuantizeDequantizationValues createEmptyValues(const FakeQuantizeDequantization& dequantization,
+                                                              const element::Type& precision = element::dynamic);
 
     static bool isZeroConst(const std::shared_ptr<Node>& node);
     static bool checkZeroPoint(const std::shared_ptr<Node>& node, const DataPrecision& dataPrecision = DataPrecision());
@@ -293,8 +292,13 @@ std::shared_ptr<Node> NetworkHelper::setOutDataPrecision(std::shared_ptr<Operati
 
 template <typename T>
 std::shared_ptr<Node> make_op_pattern(const ov::NodeVector& args) {
-    return std::make_shared<ov::pass::pattern::op::Any>(element::undefined, PartialShape{},
-                                                        [](std::shared_ptr<Node> n) {return !!ov::as_type_ptr<T>(n); }, args);
+    return std::make_shared<ov::pass::pattern::op::Any>(
+        element::dynamic,
+        PartialShape{},
+        [](std::shared_ptr<Node> n) {
+            return !!ov::as_type_ptr<T>(n);
+        },
+        args);
 }
 
 template <typename T, typename... Args>

src/common/low_precision_transformations/src/concat.cpp

@@ -300,7 +300,7 @@ bool ConcatTransformation::canBeTransformed(const std::shared_ptr<Node>& layer)
         if (constant == nullptr) {
             return true;
         }
-        if (const_precision == element::undefined) {
+        if (const_precision == element::dynamic) {
             const_precision = constant->get_element_type();
             return true;
         }
@@ -320,7 +320,7 @@ bool ConcatTransformation::canBeTransformed(const std::shared_ptr<Node>& layer)
             return false;
         }
 
-        if (precision == element::undefined) {
+        if (precision == element::dynamic) {
             precision = dequantization.data.get_element_type();
         } else if (precision != dequantization.data.get_element_type()) {
             return false;

src/common/low_precision_transformations/src/fake_quantize.cpp

@@ -93,7 +93,7 @@ std::shared_ptr<opset1::Constant> getConstant(const std::shared_ptr<Node>& eltwi
 
 bool all_precisions_equal(const std::shared_ptr<Node>& node) {
     const auto& inputs = node->inputs();
-    const auto first_input_precision = inputs.empty() ? element::undefined : inputs[0].get_element_type();
+    const auto first_input_precision = inputs.empty() ? element::dynamic : inputs[0].get_element_type();
     if (!inputs.empty()) {
         const auto first_input_precision = inputs[0].get_element_type();
         if (std::any_of(
@@ -109,7 +109,7 @@ bool all_precisions_equal(const std::shared_ptr<Node>& node) {
     const auto& outputs = node->outputs();
     if (!outputs.empty()) {
         const auto first_output_precision = outputs[0].get_element_type();
-        if ((first_input_precision != element::undefined) && (first_input_precision != first_output_precision)) {
+        if ((first_input_precision != element::dynamic) && (first_input_precision != first_output_precision)) {
             return false;
         }
 

src/common/low_precision_transformations/src/fake_quantize_decomposition.cpp

@@ -306,7 +306,8 @@ bool FakeQuantizeDecompositionTransformation::transform(ov::pass::pattern::Match
 
         const DataPrecision expectedDataPrecision = fq_decomposition::getDataPrecisionByOutputPortAndFakeQuantize(layer);
         // TODO: need test to compose FakeQuantize
-        if ((expectedDataPrecision.precision == element::undefined) || (expectedDataPrecision.precision == outputPrecision)) {
+        if ((expectedDataPrecision.precision == element::dynamic) ||
+            (expectedDataPrecision.precision == outputPrecision)) {
             return rewritten;
         }
 
@@ -363,7 +364,7 @@ bool FakeQuantizeDecompositionTransformation::transform(ov::pass::pattern::Match
 
     // if IntervalsAlignment attribute is defined then, the attribute defines decomposition parameters,
     // if IntervalsAlignment attribute is not defined, then FakeQuantize operation intervals define decomposition parameters
-    if (dataPrecision.precision == element::undefined) {
+    if (dataPrecision.precision == element::dynamic) {
         element::Type precision;
         const auto levels = layer->get_levels();
         const std::vector<float> outputLowValues = ov::as_type_ptr<opset1::Constant>(layer->get_input_node_shared_ptr(3))->cast_vector<float>();

src/common/low_precision_transformations/src/layer_transformation.cpp

@@ -268,7 +268,7 @@ LayerTransformation::PrecisionDetails LayerTransformation::getPrecisionDetails(
         unsignedPrecision = !signedPrecision;
     }
 
-    element::Type resultPrecision = element::undefined;
+    element::Type resultPrecision = element::dynamic;
     // if zero point exists then result precision has to be defined by client code
     if (!hasZeroPoint) {
         if (signedPrecision && (!unsignedPrecision)) {
@@ -335,8 +335,7 @@ DataPrecision LayerTransformation::getDataPrecision(
     printDequantizationInfo(layer);
 #endif
     PrecisionDetails precisionDetailsAtOutputIntervals = getPrecisionDetails(quantizationDetails);
-
-    if (precisionDetailsAtOutputIntervals.precision != element::undefined) {
+    if (precisionDetailsAtOutputIntervals.precision != element::dynamic) {
         // FakeQuantize optimal precision not deined
         if (!requiredPrecisions.empty()) {
             const auto foundIt = std::find(requiredPrecisions.begin(), requiredPrecisions.end(), precisionDetailsAtOutputIntervals.precision);

src/common/low_precision_transformations/src/multiply_to_group_convolution.cpp

@@ -54,7 +54,7 @@ bool MultiplyToGroupConvolutionTransformation::transform(ov::pass::pattern::Matc
         dequantization = NetworkHelper::foldDequantization(multiply, inputIndex, defaultPrecisions);
     }
 
-    element::Type weightsPrecision = element::undefined;
+    element::Type weightsPrecision = element::dynamic;
     if (updatePrecisions) {
         // try to find restrictions on weights for GroupConvolution
         if (restrictions.size() > 1ul) {
@@ -65,7 +65,7 @@ bool MultiplyToGroupConvolutionTransformation::transform(ov::pass::pattern::Matc
         }
 
         // if restrictions are absent precisions attribute is used
-        if (weightsPrecision == element::undefined) {
+        if (weightsPrecision == element::dynamic) {
             const auto precisionsAttribute = getAttribute<PrecisionsAttribute>(multiply->input(inputIndex == 0ul ? 1ul : 0ul));
             const auto precisions = precisionsAttribute == nullptr ?
                 defaultPrecisions :