source: every CoreML recipe exports FP16 (YOLOv9 packages replaced in place)

source/README.md

@@ -38,10 +38,10 @@ What the recipes encode (the hosted files record each of these):
 
 | Folder | Files | ONNX | CoreML | OpenVINO IR |
 | --- | --- | --- | --- | --- |
-| `objectDetection/yolo26` | `camstack-yolo26{n,s,m,l,x}` @640 | static, opset 17 | static, batch 1 | FP16 as `<stem>.xml` and `<stem>-fp16.xml`; INT8 `<stem>-int8.xml` (128 images) |
+| `objectDetection/yolo26` | `camstack-yolo26{n,s,m,l,x}` @640 | static, opset 17 | static, batch 1, FP16 | FP16 as `<stem>.xml` and `<stem>-fp16.xml`; INT8 `<stem>-int8.xml` (128 images) |
 | `objectDetection/yolo26` | `camstack-yolo26{n,s,m,l}-{320,256}` | dynamic axes, opset 17 | static, batch 1, FP16 | FP32 `<stem>.xml`; INT8 `<stem>-int8.xml` (128 images) |
-| `objectDetection/yolov9` | `camstack-yolov9{t,s,m,c}-{320,640}` | static, opset 13 | static, batch 1 | FP16 `<stem>-fp16.xml`; INT8 `<stem>-int8.xml` (300 images) |
-| `segmentation/yolo26-seg` | `camstack-yolo26{n,s,m}-seg` @640 | static, opset 17 | static, batch 1 | FP16 `<stem>.xml` |
+| `objectDetection/yolov9` | `camstack-yolov9{t,s,m,c}-{320,640}` | static, opset 13 | static, batch 1, FP16 | FP16 `<stem>-fp16.xml`; INT8 `<stem>-int8.xml` (300 images) |
+| `segmentation/yolo26-seg` | `camstack-yolo26{n,s,m}-seg` @640 | static, opset 17 | static, batch 1, FP16 | FP16 `<stem>.xml` |
 
 Recorded tool versions (Ultralytics / PyTorch / coremltools / OpenVINO):
 YOLO26 @640 and YOLO26-seg 8.4.24 / 2.10.0 / 9.0 / 2026.2.1; YOLO26 @320 and
@@ -58,6 +58,15 @@ flexible batch. They are now exported with a static batch of 1 and were
 replaced in place, under the same names. The script refuses a batch-flexible
 CoreML recipe for a YOLO26 checkpoint.
 
+Every CoreML package computes in FP16, the only precision the Apple Neural
+Engine runs. An FP32 package runs on the GPU or the CPU instead, 2–4× slower.
+The YOLOv9 packages were FP32 until 2026-10-07: Ultralytics 8.4.98 pins FP32
+unless `half=True` is passed. They were re-exported FP16 and replaced in place,
+under the same names. The YOLO26 @640 and YOLO26-seg packages record
+`half: False` but are FP16, because Ultralytics 8.4.24 left Core ML's FP16
+default in place; their recipes now pass `half=True` so a current Ultralytics
+gives the same precision. The script refuses an FP32 CoreML recipe.
+
 ### INT8 calibration
 
 The INT8 IRs are NNCF post-training quantisation of the ONNX

source/build-camstack-models.py

@@ -33,7 +33,8 @@ e.g. exported-models/objectDetection/yolo26/openvino/camstack-yolo26n-320-int8.x
 
 Formats:
   onnx      Ultralytics export(format="onnx") from the upstream .pt
-  coreml    Ultralytics export(format="coreml") from the upstream .pt (macOS only)
+  coreml    Ultralytics export(format="coreml") from the upstream .pt (macOS only),
+            always FP16: an FP32 package never runs on the Neural Engine
   openvino  convert_lib.export_openvino: ov.convert_model(ONNX) + ov.save_model
             (compress_to_fp16 per precision) — never the Ultralytics OV exporter
   int8      convert_lib.quantize_openvino_int8: NNCF post-training quantisation
@@ -160,16 +161,19 @@ FP16_IR = OpenvinoOutput('', 'fp16')
 
 
 def _yolo26_full(tier: str) -> Recipe:
-    """yolo26<tier> @640: static ONNX, static fp32-compute CoreML, IR fp16 twice + INT8.
+    """yolo26<tier> @640: static ONNX, static FP16 CoreML, IR fp16 twice + INT8.
 
     The unsuffixed IR and `-fp16` IR are the same compressed-to-FP16 weights;
-    the catalog addresses both names.
+    the catalog addresses both names. The hosted CoreML packages record
+    `half: False` and still compute in FP16: Ultralytics 8.4.24 left Core ML's
+    FP16 default in place. Later Ultralytics pins FP32 unless FP16 is asked
+    for, so the recipe asks (`check_recipes`, D743).
     """
     return Recipe(
         name=f'camstack-yolo26{tier}', folder='objectDetection/yolo26', imgsz=640,
         toolchain=TC_2604, checkpoint=f'yolo26{tier}',
         onnx=OnnxExport(dynamic=False, opset=17),
-        coreml=CoremlExport(dynamic=False, batch=1, half=False),
+        coreml=CoremlExport(dynamic=False, batch=1, half=True),
         openvino=(FP16_IR, OpenvinoOutput('-fp16', 'fp16'), OpenvinoOutput('-int8', 'int8')),
         calib_samples=128,
     )
@@ -199,12 +203,19 @@ def _yolo26_reduced(tier: str, res: int) -> Recipe:
 
 
 def _yolov9(tier: str, res: int) -> Recipe:
-    """yolov9<tier>-<res>: static opset-13 ONNX, static CoreML, IR fp16 + INT8."""
+    """yolov9<tier>-<res>: static opset-13 ONNX, static FP16 CoreML, IR fp16 + INT8.
+
+    The CoreML packages were FP32 until 2026-10-07: `half=False` under
+    Ultralytics 8.4.98 pins Core ML's compute precision to FP32. The Neural
+    Engine computes in FP16 only, so Core ML ran them on the GPU (`ALL`) or the
+    CPU (`CPU_AND_NE`). The FP16 export runs on the Neural Engine and replaced
+    the FP32 one in place (D743).
+    """
     return Recipe(
         name=f'camstack-yolov9{tier}-{res}', folder='objectDetection/yolov9', imgsz=res,
         toolchain=TC_2607_YOLOV9, checkpoint=f'yolov9{tier}',
         onnx=OnnxExport(dynamic=False, opset=13),
-        coreml=CoremlExport(dynamic=False, batch=1, half=False),
+        coreml=CoremlExport(dynamic=False, batch=1, half=True),
         openvino=(OpenvinoOutput('-fp16', 'fp16'), OpenvinoOutput('-int8', 'int8')),
         calib_samples=300,
     )
@@ -215,7 +226,7 @@ def _yolo26_seg(tier: str) -> Recipe:
         name=f'camstack-yolo26{tier}-seg', folder='segmentation/yolo26-seg', imgsz=640,
         toolchain=TC_2604, checkpoint=f'yolo26{tier}-seg',
         onnx=OnnxExport(dynamic=False, opset=17),
-        coreml=CoremlExport(dynamic=False, batch=1, half=False),
+        coreml=CoremlExport(dynamic=False, batch=1, half=True),
         openvino=(FP16_IR,),
     )
 
@@ -234,14 +245,26 @@ GATHER_ND_CHECKPOINT_PREFIX = 'yolo26'
 
 
 def check_recipes(recipes: tuple[Recipe, ...]) -> list[str]:
-    """Recipes whose CoreML export Core ML cannot load; empty when all is well."""
-    return [
-        f'{r.name}: CoreML export must be static (dynamic=False, batch=1) — a '
-        f'batch-flexible {r.checkpoint} package aborts the process that loads it (D742)'
-        for r in recipes
-        if r.coreml is not None and r.coreml.dynamic
-        and r.checkpoint.startswith(GATHER_ND_CHECKPOINT_PREFIX)
-    ]
+    """Recipes whose CoreML export is unusable on a Mac; empty when all is well.
+
+    - A batch-flexible YOLO26 package aborts the process that loads it (D742).
+    - An FP32 package never runs on the Neural Engine, which computes in FP16
+      only: Core ML puts it on the GPU (`ALL`) or the CPU (`CPU_AND_NE`), 2-4x
+      slower than the FP16 package of the same model on the Neural Engine
+      (D743). Ultralytics pins FP32 unless `half` is set, so every CoreML
+      recipe sets it.
+    """
+    bad: list[str] = []
+    for r in recipes:
+        if r.coreml is None:
+            continue
+        if r.coreml.dynamic and r.checkpoint.startswith(GATHER_ND_CHECKPOINT_PREFIX):
+            bad.append(f'{r.name}: CoreML export must be static (dynamic=False, batch=1) — a '
+                       f'batch-flexible {r.checkpoint} package aborts the process that loads it (D742)')
+        if not r.coreml.half:
+            bad.append(f'{r.name}: CoreML export must be FP16 (half=True) — an FP32 package never '
+                       f'runs on the Neural Engine (D743)')
+    return bad
 
 
 FAMILIES = {
@@ -478,7 +501,7 @@ def adhoc_recipe(args: argparse.Namespace) -> Recipe:
         name=name, folder=args.folder, imgsz=args.imgsz,
         toolchain=Toolchain('any', 'any', 'any', 'any'), checkpoint=args.model,
         onnx=OnnxExport(dynamic=args.dynamic, opset=args.opset),
-        coreml=CoremlExport(dynamic=args.dynamic, batch=16 if args.dynamic else 1, half=args.half),
+        coreml=CoremlExport(dynamic=args.dynamic, batch=16 if args.dynamic else 1, half=True),
         openvino=tuple(OpenvinoOutput(f'-{p}', p) for p in precisions),
         calib_samples=args.calib_samples or 300,
     )
@@ -556,7 +579,6 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
     adhoc.add_argument('--folder', default='custom')
     adhoc.add_argument('--dynamic', action='store_true', help='dynamic axes (ONNX) / flexible batch (CoreML)')
     adhoc.add_argument('--opset', type=int, default=17)
-    adhoc.add_argument('--half', action='store_true', help='FP16 CoreML')
     adhoc.add_argument('--openvino', help='IR precisions, comma-separated: fp32,fp16,int8')
     return p.parse_args(argv)