Remove MLX artifacts: slower than Core ML on device

MLX measured slower than Core ML on an iPhone 16 for this model, at matched fp32 precision and against the shipped Core ML fp16 build. These exporters only ever declared an MLX fp32 variant, so fp32-vs-fp32 is the fair and conservative comparison, and MLX still loses it.

The .pte and config.json are removed; each mlx/ dir keeps a NOTES.md with this model's own measurements. The exporter is retained in export-scripts so this can be re-tested against a future ExecuTorch/MLX release.

MLX for these models was only ever published on main / v0.10.0; no tag at v0.9.0 or below carried it. v0.9.0 and below are untouched.

mlx/NOTES.md

@@ -0,0 +1,57 @@
+# MLX is not shipped for this model
+
+The MLX artifacts for this model were removed deliberately. The exporter in
+`export-scripts` is kept so the decision can be re-tested against a future
+ExecuTorch/MLX release, but no `.pte` or `config.json` is published here.
+
+## Why
+
+Measured on device (iPhone 16, ExecuTorch 1.4.1, Release build, 3 warmup runs +
+15 timed runs, median), on selfie-segmentation:
+
+| backend | precision | median latency |
+|---|---|---|
+| Core ML | fp32 (precision matched) | 4.5 ms |
+| MLX | fp32 (only precision offered) | 5.1 ms |
+| Core ML | fp16 (shipped default) | **0.3 ms** |
+
+MLX is **1.1x slower than Core ML at matched precision**, and **17.0x slower than
+the Core ML build that actually ships**.
+
+These exporters only ever declared an MLX fp32 variant, so fp32-vs-fp32 is the
+fair comparison and it is deliberately the conservative one: MLX still loses it.
+
+**Caveat specific to this model.** At matched precision MLX is only 1.1x behind
+Core ML, which is near parity and the closest result in this study. MLX is not
+performing badly here. It is removed because Core ML fp16 is exceptional on this
+model (0.3 ms, a 15x gain over its own fp32), and fp16 is what ships. If Core ML
+fp16 ever regressed for this model, MLX would be a reasonable fallback.
+
+## Context
+
+MLX was measured behind Core ML on every convolutional vision model tested. The
+margin varies widely with architecture, so each model carries its own number
+rather than a blanket figure.
+
+Two things compound the gap. MLX weight quantization cannot shrink a conv model:
+`quantize_model_` only rewrites `nn.Linear` and embedding modules, and
+EfficientNet-V2-S holds just 6.0% of its parameters in its single `nn.Linear`,
+so 4-bit quantization buys about 5% file size. Core ML by contrast reaches the
+convolutions.
+
+## Scope
+
+This concerns convolution-dominated vision models. It does **not** generalize:
+
+- `rfdetr-nano` (conv + transformer) measured only **1.24x** behind Core ML.
+- The `lfm2.5` text encoders measured **2.7-3.1x faster on MLX** than XNNPACK.
+
+MLX suits matmul-heavy graphs. The right backend depends on model class, so this
+file is not a statement about MLX in general.
+
+## Availability history
+
+MLX for this model was only ever published on `main` / `v0.10.0`. No earlier tag
+(`v0.9.0` and below) carried an MLX artifact for it, so there is no pinned
+revision from which these files can still be fetched. They remain recoverable
+from this repository's git history.

mlx/config.json

@@ -1,76 +0,0 @@
-{
-  "$schema": "https://huggingface.co/software-mansion/react-native-executorch-spec/resolve/main/config.schema.json",
-  "model": "selfie_segmentation",
-  "family": "selfie",
-  "capabilities": [
-    "semantic-segmentation"
-  ],
-  "backend": "mlx",
-  "license": "apache-2.0",
-  "variants": [
-    {
-      "file": "selfie_segmentation_mlx_fp32.pte",
-      "precision": "fp32",
-      "quantized": false,
-      "default": true,
-      "methods": {
-        "forward": {
-          "inputs": [
-            {
-              "shape": [
-                1,
-                3,
-                256,
-                256
-              ],
-              "dtype": "float32"
-            }
-          ],
-          "outputs": [
-            {
-              "shape": [
-                1,
-                1,
-                256,
-                256
-              ],
-              "dtype": "float32"
-            }
-          ]
-        }
-      }
-    },
-    {
-      "file": "selfie_segmentation_landscape_mlx_fp32.pte",
-      "precision": "fp32",
-      "quantized": false,
-      "default": true,
-      "methods": {
-        "forward": {
-          "inputs": [
-            {
-              "shape": [
-                1,
-                3,
-                144,
-                256
-              ],
-              "dtype": "float32"
-            }
-          ],
-          "outputs": [
-            {
-              "shape": [
-                1,
-                1,
-                144,
-                256
-              ],
-              "dtype": "float32"
-            }
-          ]
-        }
-      }
-    }
-  ]
-}

mlx/selfie_segmentation_landscape_mlx_fp32.pte

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e682609e6d6d89d4cab614239fc3fc212ad31a70f5df6e19bd6b145a026e5106
-size 482944

mlx/selfie_segmentation_mlx_fp32.pte

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:fbff091b26542dd8e69bf8ad49510a6a1b19f905190f596be82fefec5a6b7965
-size 482944