8.3 release (#2492)

* 8.3 release

* Disable flake8 + Fix external CI

---------

Co-authored-by: Gitesh  Dawer <[email protected]>

Author: DawerG

.gitlab-ci.yml

@@ -9,14 +9,16 @@ stages:
 ##
 #########################################################################
 
-check_python_flake8:
-  tags:
-    - macOS_M1
-  stage: check
-  script:
-    - python -m pip install --upgrade pip
-    - pip install flake8
-    - flake8 ./coremltools --count --select=E9,F5,F63,F7,F82 --show-source --statistics
+
+# TODO: Enable Flake8 once it's integrated in the regular dev workflow
+# check_python_flake8:
+#   tags:
+#     - macOS_M1
+#   stage: check
+#   script:
+#     - python -m pip install --upgrade pip
+#     - pip install flake8
+#     - flake8 ./coremltools --count --select=E9,F5,F63,F7,F82 --show-source --statistics
 
 
 #########################################################################

NOTICE.txt

@@ -47,7 +47,8 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 
-This project contains content in the files coremltools/optimize/torch/quantization/modules/conv_transpose.py and coremltools/optimize/torch/quantization/modules/conv_transpose_fused.py which are adapted from pytorch (https://github.com/pytorch/). The license for these follows:
+This project contains content in the files coremltools/optimize/torch/quantization/modules/conv_transpose.py, coremltools/optimize/torch/quantization/modules/conv_transpose_fused.py, coremltools/optimize/torch/quantization/modules/learnable_fake_quantize.py,
+coremltools/optimize/torch/modules/observers.py, coremltools/optimize/torch/_utils/torch_utils.py which are adapted from pytorch (https://github.com/pytorch/). The license for these follows:
 
 Copyright (c) 2016 Facebook, Inc (Adam Paszke)
 
@@ -79,3 +80,21 @@ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
+
+This project contains content in the files coremltools/optimize/torch/modules/learnable_fake_quantize.py and coremltools/optimize/torch/modules/observers.py which are adapted from MQBench (https://github.com/ModelTC/MQBench)
+
+Apache License 2.0
+
+Copyright 2025 MQBench
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	 http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

coremltools/converters/_converters_entry.py

@@ -743,7 +743,7 @@ def _validate_outputs_argument(outputs):
             raise ValueError('"outputs" must be of type list')
         if len(outputs) == 0:
             return None, None
-        if not all(map(lambda t: isinstance(t, (ImageType, str, TensorType)), outputs)):
+        if not all(map(lambda t: ((isinstance(t, InputType) and t.can_be_output()) or isinstance(t, str)), outputs)):
             raise ValueError('Elements in "outputs" must be ct.TensorType or ct.ImageType or str')
 
         msg_inconsistent_types = 'all elements of "outputs" must either be of type str ' \
@@ -754,10 +754,10 @@ def _validate_outputs_argument(outputs):
                 raise ValueError(msg_inconsistent_types)
             return outputs, [TensorType(name=name) for name in outputs]
 
-        if isinstance(outputs[0], InputType):
-            if not all([isinstance(t, TensorType) or isinstance(t, ImageType) for t in outputs]):
+        if isinstance(outputs[0], InputType) and outputs[0].can_be_output():
+            if not all([(isinstance(t, InputType) and t.can_be_output()) for t in outputs]):
                 raise ValueError(msg_inconsistent_types)
-            if any([t.shape is not None for t in outputs]):
+            if any([(isinstance(t, TensorType) or isinstance(t, ImageType)) and t.shape is not None for t in outputs]):
                 msg = "The 'shape' argument must not be specified for the outputs, since it is " \
                       "automatically inferred from the input shapes and the ops in the model"
                 raise ValueError(msg)
@@ -1011,7 +1011,7 @@ def _determine_source(model, source,
             # validate that the outputs passed by the user are of type ImageType/TensorType
             if output_argument_as_specified_by_user is not None and not all(
                 [
-                    isinstance(t, TensorType) or isinstance(t, ImageType)
+                    (isinstance(t, InputType) and t.can_be_output())
                     for t in output_argument_as_specified_by_user
                 ]
             ):

coremltools/converters/mil/backend/backend_helper.py

@@ -4,7 +4,7 @@
 #  found in the LICENSE.txt file or at https://opensource.org/licenses/BSD-3-Clause
 
 from coremltools import proto
-from coremltools.converters.mil.input_types import ColorLayout
+from coremltools.converters.mil import input_types
 from coremltools.converters.mil.mil.passes.defs.preprocess import NameSanitizer
 
 
@@ -46,11 +46,11 @@ def _get_probability_var_for_classifier(prog, classifier_config):
 
 
 def _get_colorspace_enum(color_layout):
-    if color_layout == ColorLayout.GRAYSCALE:
+    if color_layout == input_types.ColorLayout.GRAYSCALE:
         return proto.FeatureTypes_pb2.ImageFeatureType.ColorSpace.GRAYSCALE
-    elif color_layout == ColorLayout.GRAYSCALE_FLOAT16:
+    elif color_layout == input_types.ColorLayout.GRAYSCALE_FLOAT16:
         return proto.FeatureTypes_pb2.ImageFeatureType.ColorSpace.GRAYSCALE_FLOAT16
-    elif color_layout == ColorLayout.BGR:
+    elif color_layout == input_types.ColorLayout.BGR:
         return proto.FeatureTypes_pb2.ImageFeatureType.ColorSpace.BGR
     else:
         return proto.FeatureTypes_pb2.ImageFeatureType.ColorSpace.RGB
@@ -60,12 +60,18 @@ def _validate_image_input_output_shapes(color_layout, shape, name, is_input=True
     if len(shape) != 4:
         raise ValueError("Image {}, '{}', must have rank 4. Instead it has rank {}".
                          format(io_str, name, len(shape)))
-    if color_layout in (ColorLayout.BGR, ColorLayout.RGB):
+    if color_layout in (input_types.ColorLayout.BGR, input_types.ColorLayout.RGB):
         if shape[1] != 3 or shape[0] != 1:
-            raise ValueError("Shape of the RGB/BGR image {}, '{}', must be of kind (1, 3, H, W), "
-                             "i.e., first two dimensions must be (1, 3), instead they are: {}".
-                             format(io_str, name, shape[:2]))
-    elif color_layout in (ColorLayout.GRAYSCALE, ColorLayout.GRAYSCALE_FLOAT16):
+            raise ValueError(
+                "Shape of the RGB/BGR image {}, '{}', must be of kind (1, 3, H, W), "
+                "i.e., first two dimensions must be (1, 3), instead they are: {}".format(
+                    io_str, name, shape[:2]
+                )
+            )
+    elif color_layout in (
+        input_types.ColorLayout.GRAYSCALE,
+        input_types.ColorLayout.GRAYSCALE_FLOAT16,
+    ):
         if shape[1] != 1 or shape[0] != 1:
             raise ValueError("Shape of the Grayscale image {}, '{}', must be of kind (1, 1, H, W), "
                              "i.e., first two dimensions must be (1, 1), instead they are: {}".

coremltools/converters/mil/backend/mil/load.py

@@ -18,6 +18,7 @@
 )
 from coremltools import _logger as logger
 from coremltools import proto
+from coremltools.converters.mil import input_types as mil_input_types
 from coremltools.converters.mil import mil
 from coremltools.converters.mil.backend.backend_helper import _get_probability_var_for_classifier
 from coremltools.converters.mil.backend.mil import helper
@@ -33,13 +34,6 @@
     types_to_proto_primitive,
 )
 from coremltools.converters.mil.backend.nn.load import _set_optional_inputs
-from coremltools.converters.mil.input_types import (
-    ClassifierConfig,
-    EnumeratedShapes,
-    ImageType,
-    RangeDim,
-    TensorType,
-)
 from coremltools.converters.mil.mil import Block
 from coremltools.converters.mil.mil import Builder as mb
 from coremltools.converters.mil.mil import Function, Operation, Program, Var, mil_list, types
@@ -604,7 +598,7 @@ def __init__(
         mil_proto: proto.MIL_pb2.Program,
         predicted_feature_name: str,
         predicted_probabilities_name: str,
-        classifier_config: ClassifierConfig,
+        classifier_config: "mil_input_types.ClassifierConfig",
         convert_to: str,
         convert_from: str,
     ):
@@ -649,7 +643,7 @@ def get_func_input(self, func: mil.Function) -> List["proto.Model_pb2.FeatureDes
         input_shape_map = {}
 
         for input_type in input_types:
-            if isinstance(input_type, ImageType):
+            if isinstance(input_type, mil_input_types.ImageType):
                 image_input_names[input_type.name] = input_type
                 # error checking for input(s) marked as images
                 if input_type.name not in list(func.inputs.keys()):
@@ -766,8 +760,8 @@ def get_func_input(self, func: mil.Function) -> List["proto.Model_pb2.FeatureDes
             default_bound_used = False
             input_type = input_shape_map.get(name, None)
 
-            if isinstance(input_type, ImageType):
-                if isinstance(input_type.shape, EnumeratedShapes):
+            if isinstance(input_type, mil_input_types.ImageType):
+                if isinstance(input_type.shape, mil_input_types.EnumeratedShapes):
                     enumerated_shapes = []
                     for s in input_type.shape.shapes:
                         enumerated_shapes.append(
@@ -781,14 +775,14 @@ def get_func_input(self, func: mil.Function) -> List["proto.Model_pb2.FeatureDes
                     H = input_type.shape.shape[-2]
                     W = input_type.shape.shape[-1]
 
-                    if isinstance(H, RangeDim):
+                    if isinstance(H, mil_input_types.RangeDim):
                         img_range.add_height_range((H.lower_bound, H.upper_bound))
                     elif is_symbolic(H):
                         img_range.add_height_range((default_lower_bound, default_upper_bound))
                         default_bound_used = True
                     else:
                         img_range.add_height_range((H, H))
-                    if isinstance(W, RangeDim):
+                    if isinstance(W, mil_input_types.RangeDim):
                         img_range.add_width_range((W.lower_bound, W.upper_bound))
                     elif is_symbolic(W):
                         img_range.add_width_range((default_lower_bound, default_upper_bound))
@@ -799,16 +793,16 @@ def get_func_input(self, func: mil.Function) -> List["proto.Model_pb2.FeatureDes
                     flexible_shape_utils._update_image_size_range_for_feature(
                         input_features[-1], img_range
                     )
-            elif isinstance(input_type, TensorType):
-                if isinstance(input_type.shape, EnumeratedShapes):
+            elif isinstance(input_type, mil_input_types.TensorType):
+                if isinstance(input_type.shape, mil_input_types.EnumeratedShapes):
                     flexible_shape_utils._add_multiarray_ndshape_enumeration_for_feature(
                         input_features[-1], [tuple(s.shape) for s in input_type.shape.shapes]
                     )
                 else:
                     lb = []
                     ub = []
                     for s in input_type.shape.shape:
-                        if isinstance(s, RangeDim):
+                        if isinstance(s, mil_input_types.RangeDim):
                             lb.append(s.lower_bound)
                             ub.append(s.upper_bound)
                         elif is_symbolic(s):
@@ -842,7 +836,7 @@ def get_func_input(self, func: mil.Function) -> List["proto.Model_pb2.FeatureDes
                     "Some dimensions in the input shape are unknown, hence they are set to flexible ranges "
                     f"with lower bound and default value = {default_lower_bound}, and upper bound = "
                     f"{default_upper_bound}. To set different values for the default shape and upper bound, "
-                    "please use the ct.RangeDim() method as described here: "
+                    "please use the ct.mil_input_types.RangeDim() method as described here: "
                     "https://coremltools.readme.io/docs/flexible-inputs#set-the-range-for-each-dimension.",
                     UserWarning,
                 )
@@ -870,7 +864,9 @@ def get_func_output(self, func: mil.Function) -> List["proto.Model_pb2.FeatureDe
         for i, var in enumerate(func.outputs):
             output_feature_type = proto.FeatureTypes_pb2.FeatureType()
             if types.is_tensor(var.sym_type) or types.is_primitive(var.sym_type):
-                if output_types is not None and isinstance(output_types[i], ImageType):
+                if output_types is not None and isinstance(
+                    output_types[i], mil_input_types.ImageType
+                ):
                     if not types.is_tensor(var.sym_type):
                         raise ValueError(
                             "Image output, '{}', is a scalar, but it should be a tensor of rank 4".format(
@@ -883,7 +879,7 @@ def get_func_output(self, func: mil.Function) -> List["proto.Model_pb2.FeatureDe
                     shape = var.sym_type.get_shape()
                     if any_variadic(shape):
                         raise ValueError(
-                            "Variable rank model outputs, that are ImageTypes, are not supported"
+                            "Variable rank model outputs, that are mil_input_types.ImageTypes, are not supported"
                         )
                     if any_symbolic(shape):
                         # For flexible shape output, we set the imageSizeRange to [1, -1],
@@ -1054,7 +1050,7 @@ def load(
     if prog.default_function_name not in prog.functions:
         raise ValueError(f"Default function {prog.default_function_name} not found in program")
 
-    # if user has specified "ClassifierConfig", then add the "classify" op to the prog
+    # if user has specified "mil_input_types.ClassifierConfig", then add the "classify" op to the prog
     classifier_config = kwargs.get("classifier_config", None)
     predicted_feature_name, predicted_probabilities_name = None, None
     if classifier_config is not None:

coremltools/converters/mil/backend/mil/passes/adjust_io_to_supported_types.py

@@ -3,7 +3,7 @@
 #  Use of this source code is governed by a BSD-3-clause license that can be
 #  found in the LICENSE.txt file or at https://opensource.org/licenses/BSD-3-Clause
 
-from typing import Set
+from typing import Set, Tuple
 
 from coremltools import _logger as logger
 from coremltools.converters.mil._deployment_compatibility import AvailableTarget as target
@@ -67,7 +67,7 @@ class adjust_io_to_supported_types(AbstractGraphPass):
 
     def apply(self, prog):
         for name, func in prog.functions.items():
-            is_main_funtion = name == "main"
+            is_main_funtion = (name == "main")
             _adjust_io_to_supported_types(func, is_main_funtion)
 
 
@@ -78,11 +78,18 @@ def _adjust_var_dtype_helper(var, dtype):
         var._sym_type = types.tensor(dtype, var.sym_type.get_shape())
 
 
-def _get_io_supported_types(opset_version: target) -> Set[type]:
+def _get_io_supported_types(opset_version: target, input_types: Tuple["InputType"]) -> Set[type]:
     """Get Core ML I/O supported data types based on opset version."""
+    # We need to do a lazy import in order to avoid errors during import
+    from coremltools.converters.mil.input_types import ImageType
+
     supported_types = {types.fp32, types.int32}
     if opset_version is not None and opset_version >= target.iOS16:
         supported_types.add(types.fp16)
+    if opset_version is not None and opset_version >= target.iOS17:
+        if any(map(lambda t: isinstance(t, ImageType) and t.grayscale_use_uint8,
+                   input_types)):
+            supported_types.add(types.uint8)
     return supported_types
 
 
@@ -104,7 +111,7 @@ def _adjust_main_inputs(func):
         2. If the original dtype is supported in Core ML Runtime, we insert a cast op to cast the
            input from the changed dtype to the original dtype.
     """
-    _IO_SUPPORTED_TYPES = _get_io_supported_types(func.opset_version)
+    _IO_SUPPORTED_TYPES = _get_io_supported_types(func.opset_version, func.input_types)
     _RUNTIME_SUPPORTED_TYPES = _get_runtime_supported_types(func.opset_version)
 
     for input_name, input_var in func.inputs.items():
@@ -116,17 +123,23 @@ def _adjust_main_inputs(func):
             convert_to_dtype_str = types.builtin_to_string(convert_to_dtype)
             should_insert_cast = input_var.dtype in _RUNTIME_SUPPORTED_TYPES
             _adjust_var_dtype_helper(input_var, convert_to_dtype)
+            human_readable_supported_types = list(
+                map(types.builtin_to_string, _IO_SUPPORTED_TYPES)
+            )
             logger.warning(
                 f"\nInput '{input_var.name}' is of dtype {input_dtype_str}. The Core ML I/O does "
-                f"not support this dtype (supported dtypes are: {_IO_SUPPORTED_TYPES}). Consider "
+                f"not support this dtype (supported dtypes are: {human_readable_supported_types}). Consider "
                 f"setting `minimum_deployment_target` to a higher IOS version for more supported "
                 f"dtypes. This input is changed to {convert_to_dtype_str}.\n"
             )
 
             if not should_insert_cast:
+                human_readable_supported_types = list(
+                    map(types.builtin_to_string, _RUNTIME_SUPPORTED_TYPES)
+                )
                 logger.warning(
                     f"The original input dtype {input_dtype_str} is not supported in "
-                    f"Core ML Runtime (supported dtypes are: {_RUNTIME_SUPPORTED_TYPES}). Consider "
+                    f"Core ML Runtime (supported dtypes are: {human_readable_supported_types}). Consider "
                     f"setting `minimum_deployment_target` to a higher IOS version for more "
                     f"supported dtypes. We just changed the dtype and won't insert any cast op."
                 )
@@ -160,7 +173,7 @@ def _adjust_main_inputs(func):
 @block_context_manager
 def _adjust_main_outputs(func):
     """Adjust the outputs in the main func to make sure they have Core ML I/O supported types."""
-    _IO_SUPPORTED_TYPES = _get_io_supported_types(func.opset_version)
+    _IO_SUPPORTED_TYPES = _get_io_supported_types(func.opset_version, func.input_types)
 
     new_outputs = []
     for output_var in func.outputs: