ultralytics-inference 0.0.16 fix: 🐞 resolve CoreML graph_input_cast_0 crash and add regression tests (#173)

Signed-off-by: Onuralp SEZER <onuralp@ultralytics.com>
Co-authored-by: UltralyticsAssistant <web@ultralytics.com>

Author: onuralpszr

.github/workflows/ci.yml

@@ -42,11 +42,26 @@ jobs:
         run: rustup show
 
       - name: Clippy (annotate feature)
+        if: matrix.os != 'macos-latest'
         run: cargo clippy --all-targets --no-default-features --features annotate -- -D warnings
 
       - name: Tests (annotate feature)
+        if: matrix.os != 'macos-latest'
         run: cargo test --no-default-features --features annotate
 
+      # CoreML is macOS-only — covers issue #148 (GatherElements warmup) and graph_input_cast_0 fix
+      - name: Clippy (coreml + annotate)
+        if: matrix.os == 'macos-latest'
+        run: cargo clippy --all-targets --no-default-features --features "coreml,annotate" -- -D warnings
+
+      - name: Tests (coreml + annotate)
+        if: matrix.os == 'macos-latest'
+        run: cargo test --no-default-features --features "coreml,annotate"
+
+      - name: Integration tests (CoreML regression, including ignored)
+        if: matrix.os == 'macos-latest'
+        run: cargo test --no-default-features --features "coreml,annotate" --test integration_test test_coreml_model_loads_and_warms_up -- --ignored --exact
+
   # Video feature tests for Linux - FFmpeg 7 and 8
   test-video:
     name: test / linux / ffmpeg ${{ matrix.ffmpeg_version }}

Cargo.lock

@@ -2,7 +2,7 @@
 
 [package]
 name = "ultralytics-inference"
-version = "0.0.15"
+version = "0.0.16"
 edition = "2024"
 rust-version = "1.88"
 authors = [

Cargo.toml

@@ -135,7 +135,7 @@ ultralytics-inference predict --model yolo26n.onnx --source image.jpg --rect
 
 WARNING ⚠️ 'model' argument is missing. Using default '--model=yolo26n.onnx'.
 WARNING ⚠️ 'source' argument is missing. Using default images: https://ultralytics.com/images/bus.jpg, https://ultralytics.com/images/zidane.jpg
-Ultralytics Inference 0.0.15 🚀 Rust ONNX FP32 CPU
+Ultralytics Inference 0.0.16 🚀 Rust ONNX FP32 CPU
 Using ONNX Runtime CPUExecutionProvider
 YOLO26n summary: 80 classes, imgsz=(640, 640)
 
@@ -153,7 +153,7 @@ Results saved to runs/detect/predict1
 
 WARNING ⚠️ 'model' argument is missing. Using default '--model=yolo26n-seg.onnx'.
 WARNING ⚠️ 'source' argument is missing. Using default images: https://ultralytics.com/images/bus.jpg, https://ultralytics.com/images/zidane.jpg
-Ultralytics Inference 0.0.15 🚀 Rust ONNX FP32 CPU
+Ultralytics Inference 0.0.16 🚀 Rust ONNX FP32 CPU
 Using ONNX Runtime CPUExecutionProvider
 YOLO26n-seg summary: 80 classes, imgsz=(640, 640)
 
@@ -243,7 +243,7 @@ Add to your `Cargo.toml` (choose one):
 ```toml
 # Stable release from crates.io
 [dependencies]
-ultralytics-inference = "0.0.15"
+ultralytics-inference = "0.0.16"
 ```
 
 ```toml

README.md

@@ -155,8 +155,12 @@ impl YOLOModel {
                 }
                 #[cfg(feature = "coreml")]
                 crate::Device::CoreMl => {
-                    eps.push(Self::build_coreml_ep(path));
-                    provider_name = "CoreMLExecutionProvider";
+                    if matches!(Self::macos_version(), Some((major, _)) if major >= 11) {
+                        eps.push(Self::build_coreml_ep(path));
+                        provider_name = "CoreMLExecutionProvider";
+                    } else {
+                        warn!("WARNING ⚠️  CoreML requires macOS 11+; falling back to CPU.");
+                    }
                 }
                 #[cfg(feature = "tensorrt")]
                 crate::Device::TensorRt(i) => {
@@ -222,7 +226,7 @@ impl YOLOModel {
             }
 
             #[cfg(feature = "coreml")]
-            {
+            if matches!(Self::macos_version(), Some((major, _)) if major >= 11) {
                 eps.push(Self::build_coreml_ep(path));
                 if provider_name == "CPUExecutionProvider" {
                     provider_name = "CoreMLExecutionProvider";
@@ -433,19 +437,12 @@ impl YOLOModel {
     #[cfg(feature = "coreml")]
     fn build_coreml_ep(model_path: &Path) -> ort::execution_providers::ExecutionProviderDispatch {
         use ort::execution_providers::coreml::ModelFormat;
-        let format = match Self::macos_version() {
-            Some((major, _)) if major >= 12 => ModelFormat::MLProgram,
-            ver => {
-                let label = ver.map_or_else(
-                    || "unknown".to_owned(),
-                    |(maj, min)| format!("{maj}.{min} < 12"),
-                );
-                warn!(
-                    "WARNING ⚠️ macOS {label}: CoreML using NeuralNetwork format; FP16 models may fail."
-                );
-                ModelFormat::NeuralNetwork
-            }
-        };
+        // `MLProgram` (macOS 12+) causes ORT's `CoreML` EP to insert a FP32→FP16 cast node at
+        // graph input, renaming it from the `ONNX` name (e.g. "images") to "graph_input_cast_0".
+        // ORT then feeds the tensor by the original name, which `CoreML` can't find → crash.
+        // `NeuralNetwork` (`CoreML` 3, macOS 10.15+) avoids the rename and supports FP16 inputs
+        // natively — confirmed working with both `FP32` and `FP16` `YOLO` `ONNX` models on macOS 12+.
+        let format = ModelFormat::NeuralNetwork;
         let mut ep =
             ort::execution_providers::CoreMLExecutionProvider::default().with_model_format(format);
 
@@ -518,11 +515,7 @@ impl YOLOModel {
 
         if let Err(e) = warmup_result {
             let msg = e.to_string();
-            // CoreML + all-zeros input: GatherElements out-of-range in the DFL head is benign.
-            if self.execution_provider != "CoreMLExecutionProvider"
-                || !msg.contains("GatherElements")
-                || !msg.contains("Out of range")
-            {
+            if !is_benign_coreml_warmup_error(&self.execution_provider, &msg) {
                 return Err(e);
             }
         }
@@ -1161,6 +1154,15 @@ impl std::fmt::Debug for YOLOModel {
     }
 }
 
+/// Returns true if `err` is the benign `GatherElements` out-of-range error that `CoreML` produces
+/// on all-zeros dummy input (issue #148). All other errors, including `graph_input_cast_0`,
+/// must propagate so callers see real failures.
+fn is_benign_coreml_warmup_error(provider: &str, msg: &str) -> bool {
+    provider == "CoreMLExecutionProvider"
+        && msg.contains("GatherElements")
+        && msg.contains("Out of range")
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1212,4 +1214,60 @@ mod tests {
             assert!(debug_str.contains("num_classes"));
         }
     }
+
+    // Issue #148 , PR #149: GatherElements out-of-range on an all-zeros dummy input is benign
+    // during `CoreML` warmup (the DFL head produces invalid gather indices for zero activations).
+    #[test]
+    fn test_warmup_gather_elements_suppressed_for_coreml() {
+        assert!(is_benign_coreml_warmup_error(
+            "CoreMLExecutionProvider",
+            "GatherElements op: Out of range value in index tensor"
+        ));
+    }
+
+    // The same GatherElements error on CPU/CUDA is a real bug and must not be hidden.
+    #[test]
+    fn test_warmup_gather_elements_propagates_for_other_providers() {
+        assert!(!is_benign_coreml_warmup_error(
+            "CPUExecutionProvider",
+            "GatherElements op: Out of range value in index tensor"
+        ));
+        assert!(!is_benign_coreml_warmup_error(
+            "CUDAExecutionProvider",
+            "GatherElements op: Out of range value in index tensor"
+        ));
+    }
+
+    // graph_input_cast_0 is a real `CoreML` misconfiguration (MLProgram adds a cast node that
+    // renames the ONNX input). It must propagate so the caller sees the failure.
+    // The fix (`NeuralNetwork` format) prevents this error from occurring at all, but it must
+    // never be silently swallowed if it somehow reappears.
+    #[test]
+    fn test_warmup_graph_input_cast_error_propagates() {
+        assert!(!is_benign_coreml_warmup_error(
+            "CoreMLExecutionProvider",
+            "Feature graph_input_cast_0 is required but not specified"
+        ));
+    }
+
+    // Any unrecognized `CoreML` error must propagate.
+    #[test]
+    fn test_warmup_unrecognised_coreml_error_propagates() {
+        assert!(!is_benign_coreml_warmup_error(
+            "CoreMLExecutionProvider",
+            "Some unexpected `CoreML` error"
+        ));
+    }
+
+    #[cfg(all(feature = "coreml", target_os = "macos"))]
+    #[test]
+    fn test_macos_version_parses_on_macos() {
+        let version = YOLOModel::macos_version();
+        assert!(
+            version.is_some(),
+            "macos_version() must return Some on macOS"
+        );
+        let (major, _minor) = version.unwrap();
+        assert!(major >= 10, "macOS major version should be >= 10");
+    }
 }

src/model.rs

@@ -10,6 +10,34 @@ use tempfile::tempdir;
 use ultralytics_inference::cli::args::PredictArgs;
 use ultralytics_inference::cli::predict::run_prediction;
 use ultralytics_inference::{Boxes, InferenceConfig, Results, Speed};
+#[cfg(feature = "coreml")]
+use ultralytics_inference::{Device, YOLOModel};
+
+/// End-to-end `CoreML` test covering two known regressions:
+///
+/// 1. **Issue #148 / PR #149** — `GatherElements op: Out of range` during warmup.
+///    `CoreML`'s DFL head produces out-of-range gather indices on an all-zeros dummy input.
+///    
+///
+/// 2. **`graph_input_cast_0` crash** — `MLProgram` format causes ORT's `CoreML` EP to insert a
+///    cast node, renaming the ONNX input (e.g. `images`) to `graph_input_cast_0`. ORT then
+///    feeds the tensor with the original name, which `CoreML` can't find.
+///    The fix (`NeuralNetwork` format) avoids the rename entirely.
+#[cfg(feature = "coreml")]
+#[test]
+#[ignore = "downloads a YOLO model; requires CoreML (macOS only)"]
+fn test_coreml_model_loads_and_warms_up() {
+    let temp_dir = tempdir().expect("temp dir should be created");
+    let model_path = temp_dir.path().join("yolo26n.onnx");
+
+    let config = InferenceConfig::new().with_device(Device::CoreMl);
+    let mut model = YOLOModel::load_with_config(model_path.to_string_lossy().as_ref(), config)
+        .expect("CoreML model should load");
+
+    // warmup() must succeed: graph_input_cast_0 errors are gone (`NeuralNetwork` format fix)
+    // and GatherElements out-of-range is tolerated (issue #148 fix).
+    model.warmup().expect("CoreML warmup should not fail");
+}
 
 #[test]
 #[ignore = "downloads a YOLO model and sample image"]