---
title: "Core MLとは？Create ML・coremltools 9でのモデル作成とSwift推論、Core AIとの使い分け"
url: "https://www.issoh.co.jp/tech/details/7513/"
published: 2025-07-01
updated: 2026-11-05
categories: ["AI"]
publisher: "株式会社一創"
---

# Core MLとは？Create ML・coremltools 9でのモデル作成とSwift推論、Core AIとの使い分け

Core MLは、学習済みの機械学習モデルをiPhone・Mac・Apple Watchなどの端末上で推論させるAppleのフレームワークです。2017年のiOS 11から使えます。モデルはCreate MLで学習するか、PyTorchなどで作ったものをcoremltoolsで変換して用意し、SwiftからCPU・GPU・Neural Engineへ振り分けて実行します。

この記事では、モデルの入手・作成からVisionとSwiftでの推論、量子化の効果までを、coremltools 9.0とSwift 6.3で実行したコード付きで説明します。2026年9月のiOS 27でニューラルネット向けの新フレームワーク「Core AI」が加わったため、どちらを選ぶかの判断基準も扱います。

## まとめ：Core MLの要点と2026年11月時点の位置づけ

- Core MLは端末内で推論するフレームワーク。通信不要で、入力データを外部サーバーへ送らずに済む。
- モデルの用意は3通り。Appleなどが公開している変換済みモデルを使う、画像・テキスト・音声・表形式などの定番タスクをCreate MLで学習する、PyTorchやTensorFlowのモデルをcoremltools（現行の安定版は9.0）で変換する。
- 現在の標準形式はML Program（`.mlpackage`）。coremltools 7以降は何も指定しなければこの形式で出力され、計算精度はFP16が既定になる。
- ONNXからの直接変換は現行のcoremltoolsにはない。PyTorchなど元のフレームワークから変換する。
- 画像を入れるモデルはVision経由で呼ぶと、縮小・切り抜きをVisionが引き受ける。iOS 18以降はSwift向けの`CoreMLRequest`、それより前も対象なら`VNCoreMLRequest`を使う。
- iOS 27以上だけを対象に新しくニューラルネットを組み込むなら、AppleはCore AIを推奨している。iOS 26以前も対象にするアプリと、決定木などの従来型モデルは引き続きCore MLが担う。

以下、位置づけ→形式→入手と作り方→Swiftでの推論→軽量化と性能確認の順に説明します。

## Core MLの役割：Apple製デバイスで学習済みモデルを推論するフレームワーク

Core MLの中心は推論で、アプリに同梱した（または後からダウンロードした）モデルに入力を渡し、分類結果や数値を返します。対応するモデルなら、端末内で利用者のデータを使った再学習・ファインチューニングもできます。ただし、この端末内学習（`MLUpdateTask`・iOS 13以降）で更新できるのはNeural Network形式のニューラルネット・パイプライン・最近傍法のモデルで、[coremltoolsの形式比較ガイド](https://apple.github.io/coremltools/docs-guides/source/comparing-ml-programs-and-neural-networks.html)は現行の標準形式であるML Programを端末内学習の未対応機能に挙げています。

実行時には、モデルの計算グラフをNeural Engine向け・GPU向け・CPU向けの区間に自動で分割します（WWDC21セッション10038）。開発者が演算ごとにハードウェアを割り当てる必要はありません。画像解析のVision、テキスト処理のNatural Language、音声認識のSpeech、音の識別のSound AnalysisもCore MLの上に作られており、用途が合えば自前のモデルを用意せずにこれらのAPIだけで済みます。

Appleの機械学習関連フレームワークのうち、ここでは役割の異なる4つを比較します。[WWDC26のグループラボ（セッション8121）](https://developer.apple.com/videos/play/wwdc2026/8121/)でAppleのエンジニアが説明した役割分担を表にまとめました。

| フレームワーク           | 扱うもの                        | 対応OS                 |
| ----------------- | --------------------------- | -------------------- |
| Foundation Models | Apple Intelligenceの言語モデルを呼ぶ | iOS 26以降             |
| Core AI           | 自前のニューラルネット（.aimodel）       | iOS 27以降             |
| Core ML           | Core MLモデル全般・決定木など従来型       | iOS 11以降             |
| MLX               | Mac上での学習・大規模モデル実行           | macOS（Apple silicon） |

言語モデルでテキストを生成したいだけなら、Core MLでモデルを持ち込むよりFoundation Modelsのほうが手数は少なくなります。詳細は[Foundation Models Frameworkの解説記事](/tech/details/9181/)で扱っています。

## iOS 27で登場したCore AIとCore MLの使い分け

### Core AIの概要：.aimodel形式とiOS 27以降の対応OS

Core AIは[WWDC26](/tech/details/11565/)で発表され、iOS 27・iPadOS 27・macOS 27・watchOS 27・tvOS 27・visionOS 27から使える推論フレームワークです。Appleはセッション[「Meet Core AI」（324）](https://developer.apple.com/videos/play/wwdc2026/324/)で、Apple Intelligenceのオンデバイス推論を支えている基盤を開発者に開放したものだと説明しています。

Core MLとは道具立てがほぼ別物です。モデル形式は`.aimodel`、PyTorchからの変換にはcoremltoolsではなく`coreai-torch`（PyPIの現行版は0.4.3・Python 3.11以上）を使い、Swift側も`AIModel`・`InferenceFunction`・`NDArray`という別のAPIです。`coreai-build`による事前コンパイルや、テンソル値をPythonのソース行まで遡れるCore AI Debuggerも用意されています。[Core AIのドキュメント](https://developer.apple.com/documentation/coreai)は、変換前の圧縮に`coreai-optimization`、書き出し済みモデルの手順集にGitHubの`apple/coreai-models`を案内しています。

Core MLが非推奨になったわけではありません。[Core MLのドキュメント](https://developer.apple.com/documentation/coreml)は「最新のアーキテクチャや推論手法を使うならCore AIを参照」と案内し、Core AIのドキュメントは「決定木や表形式の特徴量エンジニアリングなどニューラルネット以外のモデルはCore MLを参照」と案内しており、守備範囲を分けています。ただしWWDC26のグループラボでは、Appleのエンジニアが「今後ニューラルネットを扱う人にはCore AIを使ってほしい。Core MLは決定木のような従来型の機械学習に軸足を置く」と発言しています。

### Core MLを選ぶ条件とCore AIへ移る条件

判断の軸は、アプリが対応するOSの下限です。

- **iOS 26以前も対象にする**：Core AIはiOS 27未満で動かないため、Core MLを使う。既存端末のOS更新状況に合わせて対応範囲を決める。
- **決定木・ブースティング・表形式データの回帰や分類**：AppleがCore MLの領域と明言している。Create MLの表形式データで作るブースティング木などのモデルもここに入る。
- **iOS 27以上が下限の新規アプリで、画像生成・セグメンテーション・小型LLMなどのニューラルネットを載せる**：Core AIを第一候補にする。
- **既存のCore MLモデルが動いているアプリ**：OSの下限をiOS 27へ上げる時点が移行の検討タイミング。動いているものを急いで書き換える理由はない。

## Core MLモデルの形式：ML Program（.mlpackage）とNeural Network（.mlmodel）

Core MLでニューラルネットワークを表す主な形式は、Neural NetworkとML Programの2つです。古いNeural Network形式は重みを各レイヤーに埋め込み、ML Program形式は型付きの演算列で計算を表して重みを別ファイルに分けて保存します。

| 項目          | ML Program        | Neural Network                       |
| ----------- | ----------------- | ------------------------------------ |
| 保存形式        | .mlpackageのみ      | .mlmodel または .mlpackage              |
| 最小対応OS      | iOS 15 / macOS 12 | iOS 11 / macOS 10.13（使用演算・変換条件により上昇） |
| 重みの持ち方      | 本体と分離（weight.bin） | レイヤーに埋め込み                            |
| 変換時の既定の重み精度 | FP16              | FP32                                 |
| iOS 18の新機能  | 対応                | 非対応                                  |

coremltools 7.0以降は、`convert_to`と`minimum_deployment_target`を省略するとML Program（iOS 15 / macOS 12以上）を出力します。`minimum_deployment_target`にiOS 14以下を指定するとNeural Networkになります。iOS 18 / macOS 15で加わった状態付きモデル（Stateful Models、LLMのKVキャッシュ保持などに使う）、1つのファイルに複数の推論関数を持たせて重みを共有するMultifunction Models、4bitのブロック単位量子化は、すべてML Program専用です。新しく作るモデルをNeural Networkにする理由は、iOS 14以前への対応、端末内学習（前述の`MLUpdateTask`）、Neural Network向けのカスタムレイヤーのいずれかが必要な場合に限られます。

保存した`.mlpackage`は中身がディレクトリで、`Manifest.json`と`Data/com.apple.CoreML/`の下に`model.mlmodel`（演算の定義）と`weights/weight.bin`が入っています。アプリが実際に読み込むのは、これを端末向けにコンパイルした`.mlmodelc`です。Xcodeはビルド時に自動でコンパイルします。

## 公開済みのCore MLモデルを入手する：Apple公式の一覧とHugging Face

画像分類・深度推定・セグメンテーションのような定番タスクなら、自分で学習や変換をする前に、変換済みのモデルを探すのが早道です。[AppleのCore ML Modelsページ](https://developer.apple.com/machine-learning/models/)は、FastViT・Depth Anything V2・DETR（セマンティックセグメンテーション）・BERT-SQuAD・DeepLabv3・MNIST・MobileNetV2・ResNet-50・Updatable Drawing Classifier・YOLOv3の10モデルを`.mlpackage`または`.mlmodel`で配布しています。FastViTのように、サイズ違いの版と端末ごとの推論時間が載っているモデルもあります。

| FastViTの版  | パラメータ数 | ファイル   | iPhone 16 Pro | iPhone 13 Pro Max |
| ---------- | ------ | ------ | ------------- | ----------------- |
| T8（FP16）   | 3.6M   | 8.2MB  | 0.52ms        | 0.83ms            |
| MA36（FP16） | 42.7M  | 88.3MB | 2.78ms        | 4.47ms            |

数値はApple公式ページの掲載値で、計算ユニットは`.all`、測定時のOSはiPhone 16 ProがiOS 18.3、iPhone 13 Pro MaxがiOS 17.6です。同じタスクでもパラメータ数が約12倍になると、ファイルは約11倍、iPhone 16 Proでの推論時間は約5倍になります。まず小さい版で精度が足りるかを確かめ、足りないときだけ大きい版へ上げるのが、アプリのサイズを抑える順番です。

Hugging Faceの`apple`アカウントにも、Appleが変換したCore MLモデルが置かれています（2026年11月5日にAPIで「coreml」を名前に含むものを数えると29件）。ダウンロード数が多いのは`coreml-depth-anything-v2-small`・`coreml-mobileclip`・`coreml-sam2.1`系で、Stable Diffusionの変換済み重み（`coreml-stable-diffusion-2-1-base`など）もここにあります。公開モデルを使うときは、モデルカードのライセンスと、入出力の名前・画像サイズを確かめてから組み込みます。

## Core MLモデルの作り方：Create MLとcoremltoolsの2通り

### Create MLによるコード不要のモデル学習

Create MLはXcodeに同梱されたアプリで、Xcodeのメニュー「Open Developer Tool」から起動します。学習データのフォルダを指定するとモデルを学習し、そのままCore MLモデルとして書き出せます。「写真を自社製品の5種類に分類する」といったタスクなら、ラベル付きの学習・検証データを用意し、画面操作でモデルを作成できます。作れるモデルは、[Create MLのドキュメント](https://developer.apple.com/documentation/createml)の分類で次のとおりです。

- **画像**：画像分類・物体検出・手のポーズ分類
- **動画**：動作分類・手の動作分類・スタイル変換
- **テキスト**：テキスト分類・単語タグ付け（固有表現の抽出など）
- **音声・モーション**：音の分類、加速度センサーなどによる活動分類
- **表形式**：分類・回帰・レコメンド

WWDC26では、visionOSなどで現実の物体を追跡する参照オブジェクトの学習に、手に持った物体の追跡精度を上げる「extended」モードが加わりました（[セッション283](https://developer.apple.com/videos/play/wwdc2026/283/)）。

コードから同じ学習を回したい場合は、Swiftの`CreateML`フレームワークと、前処理を部品として組める`Create ML Components`を使います。Create MLを動かすにはMacが必要です。2026年10月29日公開の安定版Xcode 27.2はmacOS Tahoe 26.6以降が要件で、[Xcode 27のリリースノート](https://developer.apple.com/documentation/xcode-release-notes/xcode-27-release-notes)は「Xcode 27はApple silicon搭載Macでだけインストール・実行できる」としています。Intel MacではXcode 26までに留まります。

Create MLで足りないのは、独自のネットワーク構造を使いたい場合と、学習済みの公開モデルを流用したい場合です。そのときは次のcoremltoolsへ進みます。

### coremltools 9によるPyTorchモデルの変換

coremltoolsはAppleが公開しているPythonパッケージで、[PyPIの最新安定版](https://pypi.org/project/coremltools/)は9.0（2025年11月10日公開）です。2026年8月に9.1.dev1が出ていますが開発版で、2026年11月時点の安定版は9.0のままです。Python 3.7〜3.13向けのwheelがmacOS（Intel・Apple silicon）とLinuxに用意されています（Apple silicon向けは3.8以降）。直接変換できる元フレームワークはPyTorchとTensorFlow（1系・2系）で、PyTorchは`torch.jit.trace`で作るTorchScriptと、`torch.export.export`で作るExportedProgramのどちらも受け付けます。

次のコードは、ランダム初期化した未学習の画像分類用ネットワークをTorchScript経由で変換し、Mac上でPyTorchとの出力差を確かめる例です。実用的な分類性能を持つモデルではありません。macOS 26.6.2（Intel Mac）、Python 3.11、PyTorch 2.2.2、coremltools 9.0で実行しました。

```
import torch, numpy as np, coremltools as ct
from PIL import Image

torch.manual_seed(0)
np.random.seed(0)

class TinyNet(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = torch.nn.Conv2d(3, 8, 3, padding=1)
        self.pool = torch.nn.AdaptiveAvgPool2d(1)
        self.fc = torch.nn.Linear(8, 2)
    def forward(self, x):
        x = torch.relu(self.conv(x))
        return torch.softmax(self.fc(self.pool(x).flatten(1)), dim=1)

model = TinyNet().eval()
example = torch.rand(1, 3, 224, 224)
traced = torch.jit.trace(model, example)

mlmodel = ct.convert(
    traced,
    inputs=[ct.ImageType(name="image", shape=example.shape, scale=1/255.0)],
    outputs=[ct.TensorType(name="probs")],
    minimum_deployment_target=ct.target.iOS17,
)
mlmodel.save("TinyNet.mlpackage")

img = Image.fromarray((np.random.rand(224, 224, 3) * 255).astype("uint8"))
print(mlmodel.predict({"image": img})["probs"])
x = torch.from_numpy(np.asarray(img, dtype=np.float32).transpose(2, 0, 1)[None] / 255.0)
print(model(x).detach().numpy())
```

出力は、Core MLが`[[0.44067383 0.55908203]]`、PyTorchが`[[0.44070387 0.5592961 ]]`でした（乱数を固定しているので、同じ版の環境で再実行すると同じ値になります）。差が小数第4位に出ているのは、ML ProgramがFP16で計算しているためです。保存された`TinyNet.mlpackage`の入力は画像型（imageType）、出力は多次元配列型（multiArrayType）になっています。

`predict()`はmacOSのCore ML本体を呼ぶため、Linuxではモデルの変換と保存まではできても推論の確認はできません。Linuxで変換し、Macや実機で検証するという分担になります。

## coremltoolsの変換でつまずく箇所

変換自体は数行ですが、エラーにならずに結果だけがずれる落とし穴がいくつかあります。

- **PyTorchの版**：coremltools 9.0が動作を確認しているのはPyTorch 2.7.0まで、TensorFlowは2.12.0までです（パッケージ内の`_TORCH_MAX_VERSION`・`_TF_2_MAX_VERSION`）。これより新しい版は警告付きで変換を試みます。変換用の環境はPyTorchの版を下げて分けるのが確実です。
- **入力の正規化**：学習時に画素を0〜1へ割っていたなら、`ImageType`の`scale=1/255.0`（必要なら`bias`も）で同じ前処理を変換時に入れます。忘れても変換は成功し、推論結果だけがおかしくなります。
- **入出力の名前**：名前を指定しないと、出力は`var_10`のような自動名に変わります（変換時に「has been renamed」という警告が出ます）。Swift側の自動生成クラスのプロパティ名になるので、`inputs`・`outputs`で明示します。
- **FP16による誤差**：既定のFP16で精度が足りない場合は`compute_precision=ct.precision.FLOAT32`を指定します。後述の軽量化の章の実測ではFP32にすると誤差が1e-7台まで下がり、ファイルサイズは2倍になりました。
- **可変長の入力**：Core MLモデルの入力形状は、`torch.jit.trace`に渡した例示入力ではなく、変換時の`inputs`の宣言で決まります。画像サイズや系列長を可変にするには`ct.RangeDim`や`ct.EnumeratedShapes`で入力形状を宣言します。

ONNX形式のモデルしか手元にない場合も注意が必要です。coremltools 4以降はUnified Conversion APIに一本化され、ONNXを読む`onnx-coreml`コンバータは凍結されて保守されていません（[coremltoolsのFAQ](https://apple.github.io/coremltools/docs-guides/source/faqs.html)）。coremltools 9.0の`ct.convert`が受け付ける`source`も`pytorch`・`tensorflow`などで、ONNXは含まれません。元のPyTorchやTensorFlowのモデルに戻って変換してください。ONNX自体の仕組みと変換の流れは[ONNXの.onnxファイルと変換の解説](/tech/details/7528/)にまとめています。

## SwiftによるCore MLモデルの読み込みと推論

### Xcodeへのモデル追加と自動生成クラスによる呼び出し

最も簡単なのは、`.mlpackage`（または`.mlmodel`）をXcodeのプロジェクトにドラッグする方法です。Xcodeがビルド時に`.mlmodelc`へコンパイルし、モデル名と同じSwiftクラスを生成します。`TinyNet.mlpackage`なら`TinyNet`クラスができ、入力名`image`・出力名`probs`がそのままプロパティ名になります。変換時に名前を付けておく理由はここにあります。

### Visionで画像分類モデルを呼ぶ：CoreMLRequestとVNCoreMLRequest

画像を入れるモデルはVision経由で呼ぶと、カメラ画像や写真をモデルの入力サイズへ縮小・切り抜く処理をVisionが引き受けます。物体検出のようにバウンディングボックスを返すモデルもVision経由が楽です。分類モデルとして結果を受け取るには、変換時に`ct.ClassifierConfig`でラベルを渡しておきます。次のコードは、前述の`TinyNet`の全結合層を3クラス出力（`torch.nn.Linear(8, 3)`）に変えたうえで、同じ`torch.manual_seed(0)`から作り直してtraceしたものを変換し、Swiftで読む確認用の画像も保存します。

```
torch.manual_seed(0)
model = TinyNet().eval()
traced = torch.jit.trace(model, torch.rand(1, 3, 224, 224))
mlmodel = ct.convert(
    traced,
    inputs=[ct.ImageType(name="image", shape=(1, 3, 224, 224), scale=1/255.0)],
    classifier_config=ct.ClassifierConfig(["cat", "dog", "bird"]),
    minimum_deployment_target=ct.target.iOS17,
)
mlmodel.save("TinyClassifier.mlpackage")
Image.fromarray((np.random.RandomState(0).rand(224, 224, 3) * 255).astype("uint8")).save("test.png")
```

こうして作ったモデルの出力は`classLabel`（予測ラベル）と`classLabel_probs`（ラベルごとの確率）になります。Visionには呼び方が2つあります。[CoreMLRequest](https://developer.apple.com/documentation/vision/coremlrequest)はiOS 18・macOS 15で加わったSwift向けの新API、`VNCoreMLRequest`はiOS 11からある従来APIです。次のコードは同じモデルと画像を両方で推論します。

```
import CoreML
import Vision
import Foundation

@main struct Main {
    static func main() async throws {
        let compiled = try await MLModel.compileModel(at: URL(fileURLWithPath: "TinyClassifier.mlpackage"))
        let mlModel = try await MLModel.load(contentsOf: compiled, configuration: MLModelConfiguration())
        let imageURL = URL(fileURLWithPath: "test.png")

        let container = try CoreMLModelContainer(model: mlModel)
        var request = CoreMLRequest(model: container)
        request.cropAndScaleAction = .centerCrop
        for case let obs as ClassificationObservation in try await request.perform(on: imageURL) {
            print("new", obs.identifier, obs.confidence)
        }

        let vnRequest = VNCoreMLRequest(model: try VNCoreMLModel(for: mlModel))
        vnRequest.imageCropAndScaleOption = .centerCrop
        try VNImageRequestHandler(url: imageURL).perform([vnRequest])
        for obs in (vnRequest.results as? [VNClassificationObservation]) ?? [] {
            print("old", obs.identifier, obs.confidence)
        }
    }
}
```

macOS 26.6.2・Swift 6.3.3（Command Line Tools）でビルドして実行すると、どちらも`dog 0.35906214`・`cat 0.3504088`・`bird 0.290529`の順で、coremltoolsの`predict()`と同じ確率を返しました（未学習のモデルなので、値は動作確認のためのものです）。新APIは`async`で結果を返し、確率の高い順に並んだ`ClassificationObservation`の配列になります。アプリの対応OSがiOS 18以上なら新API、iOS 17以前も対象なら従来APIを選びます。

### ダウンロード済みCore MLモデルの実行時コンパイル

アプリ本体を更新せずにモデルだけ差し替えたい場合は、ダウンロードした`.mlpackage`を端末上でコンパイルします。例として、入力名`x`（1×1024）・出力名`y`の全結合モデルを次のPythonで作り、`fp16.mlpackage`として保存します。

```
import torch, coremltools as ct

torch.manual_seed(0)
model = torch.nn.Sequential(
    torch.nn.Linear(1024, 1024), torch.nn.ReLU(), torch.nn.Linear(1024, 10)
).eval()
traced = torch.jit.trace(model, torch.rand(1, 1024))

mlmodel = ct.convert(
    traced,
    inputs=[ct.TensorType(name="x", shape=(1, 1024))],
    outputs=[ct.TensorType(name="y")],
    minimum_deployment_target=ct.target.iOS17,
)
mlmodel.save("fp16.mlpackage")
```

このモデルをSwiftでコンパイルして読み込み、推論します。`@main`を含む1ファイルなので、`xcrun swiftc -parse-as-library main.swift -o main`でビルドしてから`./main`で実行します（この記事のSwiftコードはすべて同じ手順です）。macOS 26.6.2上でSwift 6.3.3（Command Line Tools）を使ってビルド・実行すると、出力`y`の形状`[1, 10]`が表示されました。`MLMultiArray(shape:dataType:)`で確保した配列の中身は未初期化なので、値を必ず書き込んでから渡します。

```
import CoreML
import Foundation

func loadModel(from packageURL: URL) async throws -> MLModel {
    let compiledURL = try await MLModel.compileModel(at: packageURL)
    let config = MLModelConfiguration()
    config.computeUnits = .cpuAndNeuralEngine
    return try await MLModel.load(contentsOf: compiledURL, configuration: config)
}

@main struct Main {
    static func main() async throws {
        let model = try await loadModel(from: URL(fileURLWithPath: "fp16.mlpackage"))
        let x = try MLMultiArray(shape: [1, 1024], dataType: .float32)
        for i in 0..<x.count { x[i] = 0.5 }
        let input = try MLDictionaryFeatureProvider(dictionary: ["x": MLFeatureValue(multiArray: x)])
        let out = try await model.prediction(from: input)
        print(out.featureValue(for: "y")!.multiArrayValue!.shape)
    }
}
```

`compileModel(at:)`が返すのは一時ディレクトリに作られた`.mlmodelc`のURLです（実行時は`fp16_<UUID>.mlmodelc`という名前でした）。一時領域は消えることがあるので、毎回コンパイルし直さないならApplication Supportなどへ移して保存します。モデルの配信には、かつてのCore ML Model Deployment（`MLModelCollection`）がiOS 17.4で非推奨になっており、AppleはBackground AssetsかURLSessionを使うよう案内しています。

### MLTensorによる前処理・後処理（iOS 18以降）

iOS 18・macOS 15で加わった[MLTensor](https://developer.apple.com/documentation/coreml/mltensor)は、モデルの前後に挟む計算（正規化・softmax・上位候補の抽出など）をSwiftで書くための多次元配列です。`MLMultiArray`を1要素ずつ回すコードを書かずに、テンソル演算としてCPU・GPUへ任せられます。

```
import CoreML

@main struct Main {
    static func main() async {
        let logits = MLTensor([2.0, 1.0, 0.1] as [Float])
        let probs = logits.softmax()
        print(await probs.shapedArray(of: Float.self).scalars)
        print(await probs.argmax().shapedArray(of: Int32.self).scalars)
    }
}
```

実行すると`[0.6590012, 0.24243298, 0.09856589]`と`[0]`が出力されました。演算は遅延実行で、値を取り出す`shapedArray(of:)`の呼び出しが`await`になる点に注意します。同じiOS 18では、LLMのKVキャッシュのような状態をモデル呼び出しの間で保持する`MLState`も加わりました。

### computeUnitsによる使用ハードウェアの指定

`MLModelConfiguration`の`computeUnits`は4値です。既定は`.all`で、Core MLが速いと判断した組み合わせを選びます。

| 値                   | 使う演算器                 | 主な用途                  |
| ------------------- | --------------------- | --------------------- |
| .all（既定）            | CPU・GPU・Neural Engine | 通常はこれ                 |
| .cpuAndNeuralEngine | CPU・Neural Engine     | GPUを描画に空けたい（iOS 16以降） |
| .cpuAndGPU          | CPU・GPU               | Neural Engineで遅い演算がある |
| .cpuOnly            | CPU                   | 結果の再現性確認・デバッグ         |

指定しても、その演算器で必ず動くとは限りません。Neural Engineが扱えない演算は、指定したcomputeUnitsで許可されるCPUやGPUへ回り、データの移動コストを含めてCPUのほうが速ければ、Neural Engine対応の演算でもCPUで実行されます。どの演算がNeural Engineに載ったかを確かめる方法は、[Neural Engine（ANE）の世代別性能とCore MLでの使い方](/tech/details/11414/)で詳しく扱っています。

## モデルの軽量化：量子化・パレット化によるサイズと誤差の実測

アプリのダウンロードサイズとメモリを抑えるため、`coremltools.optimize`で変換済みモデルの重みを圧縮できます。前章の`fp16.mlpackage`には、次のように8bit線形量子化と4bitパレット化をかけました。

```
import coremltools as ct
import coremltools.optimize as cto

mlmodel = ct.models.MLModel("fp16.mlpackage")

q8 = cto.coreml.linear_quantize_weights(
    mlmodel,
    config=cto.coreml.OptimizationConfig(
        global_config=cto.coreml.OpLinearQuantizerConfig(mode="linear_symmetric")
    ),
)
q8.save("int8.mlpackage")

p4 = cto.coreml.palettize_weights(
    mlmodel,
    config=cto.coreml.OptimizationConfig(
        global_config=cto.coreml.OpPalettizerConfig(mode="kmeans", nbits=4)
    ),
)
p4.save("pal4.mlpackage")
```

同じモデル（重み約106万個）を形式・圧縮方法ごとに保存し、ファイルの合計サイズと、乱数固定の入力100件に対するPyTorch出力との差を`CPU_ONLY`で測りました。モデルは未学習なので、誤差と一致率は圧縮による出力の変化の大きさを比べるための値です。

| 形式・圧縮                | ファイルサイズ | 最大絶対誤差 | 最大値の位置の一致 | 形式・機能の最小OS |
| -------------------- | ------- | ------ | --------- | ---------- |
| Neural Network（FP32） | 4.24MB  | 2.1e-7 | 100%      | iOS 11以降   |
| ML Program FP32      | 4.24MB  | 2.1e-7 | 100%      | iOS 15以降   |
| ML Program FP16（既定）  | 2.12MB  | 2.8e-4 | 100%      | iOS 15以降   |
| 8bit線形量子化            | 1.07MB  | 2.2e-3 | 99%       | iOS 16以降   |
| 4bitパレット化（k-means）   | 0.53MB  | 3.9e-2 | 90%       | iOS 16以降   |

右端の列は、その形式や圧縮方法が使えるようになったOSです。今回保存したファイルそのものは、Neural Network版がspecificationVersion 4（iOS 13以降）、ML Program版は`minimum_deployment_target=ct.target.iOS17`で変換したためspecificationVersion 8（iOS 17以降）になっています。

サイズはビット数にほぼ比例して縮み、4bitではFP16の4分の1になりました。一方で、出力が最大になる位置（分類なら予測クラス）がPyTorchと一致した割合は、8bitで99%、4bitで90%まで下がっています。学習済みモデルでの劣化幅はモデルごとに違うため、圧縮は検証データで精度を測ってから採用します。

圧縮の効き方は演算器によって違います。coremltoolsの公式ガイドは、パレット化はNeural Engine、iOS 18で加わったINT4のブロック単位量子化はMacのGPU、プルーニング（重みの疎化）はNeural EngineとCPUで速度向上が見込めると説明しています。iOS 17ではアクティベーションも8bitにするW8A8が加わりました。量子化の一般的な考え方とPTQ・QATの違いは[量子化（モデル量子化）の解説](/tech/details/15846/)を参照してください。

## 推論速度の確認：XcodeのパフォーマンスレポートとInstruments

端末での速度は、Xcodeでモデルファイルを開いて「Performance」タブからレポートを作ると確認できます。Macまたは接続した実機でモデルを実際に動かし、読み込み時間・予測時間と、各演算がCPU・GPU・Neural Engineのどれで実行されたかを一覧にします。Xcode 26（[WWDC25セッション360](https://developer.apple.com/videos/play/wwdc2025/360/)）からは、同じモデルビューでネットワーク全体の構造を図示し、個々の演算の詳細を開けるようになりました。

アプリに組み込んだ後の挙動は、Xcode 14で追加されたInstrumentsの「Core ML」テンプレートで追います。Core ML・Neural Engine・GPU・Time Profilerの各計測をまとめたもので、読み込みが起動時間を圧迫していないか、推論がメインスレッドを止めていないかが分かります。Python側で数値のずれを調べるなら、coremltools 8.3で入った`MLModelComparator`（FP16版とFP32版、あるいはPyTorchとの出力比較）や`MLModelBenchmarker`が使えます。

## Core MLを使わない方がよい場面

Core MLは「Appleの端末だけで、自前のモデルを動かす」ための道具です。次の条件に当たるなら、対応環境や開発工数を基準に別の手段を選びます。

- **文章の要約・分類・生成をしたいだけ**：対象端末でApple Intelligenceが利用可能で、OS内蔵モデルが要件を満たすなら、Foundation Modelsを使うことで自前のモデルの変換・同梱を省ける。
- **iOS 27以上が下限で、新しいニューラルネットを載せる**：Core AIを選ぶ。今からCore ML向けの変換パイプラインを作り込む利点は小さい。
- **Mac上で大きなLLMを動かす・学習させる**：Core MLは推論中心で、学習やHugging Faceのモデルの手軽な実行には向かない。[MLXとmlx-lmの導入手順](/tech/details/17956/)で扱っているMLXが適している。
- **AndroidやWindowsでも同じモデルを使う**：Core MLはApple製OS専用。共通化を優先するなら[TensorFlow Lite（LiteRT）](/tech/details/16870/)やONNX Runtimeを使い、iOSだけCore MLに変換するかを性能差で判断する。

Core MLかCore AIか、端末内で推論するかサーバーに送るかは、アプリの対応OSと既存の機能の作りで決まります。モデルを組み込んだアプリの設計から相談したい場合は、一創の[iOSアプリ開発](/service/apps/ios/)でも承っています。

## よくある質問

### Core MLとは何ですか？

学習済みの機械学習モデルをiPhone・Mac・Apple Watchなどの端末上で推論させるAppleのフレームワークです。iOS 11（2017年）から使え、CPU・GPU・Neural Engineへ自動で処理を振り分けます。

### Create MLとCore MLの違いは何ですか？

Create MLはモデルを学習して作るツール、Core MLはできたモデルをアプリで動かすフレームワークです。Create MLで学習したモデルはCore ML形式で書き出され、そのままアプリに組み込めます。Create MLを含むXcode 27はApple silicon搭載Mac専用です。

### coremltoolsはWindowsやLinuxで使えますか？

PyPIで配布されているwheelはmacOS（Intel・Apple silicon）とLinux向けで、Windows向けはありません。Linuxではモデルの変換と保存はできますが、`predict()`はmacOSのCore ML本体を呼ぶため推論の確認はできません。

### ONNXのモデルをCore MLに変換できますか？

現行のcoremltoolsでは直接はできません。ONNXを読む`onnx-coreml`はcoremltools 4の時点で凍結され、保守されていません。元のPyTorchやTensorFlowのモデルから`ct.convert`で変換するのが公式の手順です。

### Core MLのモデルはどこで入手できますか？

AppleのCore ML Modelsページで、FastViT・Depth Anything V2・YOLOv3など10モデルが`.mlpackage`または`.mlmodel`で配布されています。Hugging Faceの`apple`アカウントにも、Appleが変換したSAM 2.1やStable Diffusionなどのモデルがあります。

## 関連記事

- [Neural Engine（ANE）とは？16コアの意味・Neural Acceleratorとの違い・M6世代の変化](/tech/details/11414/)
- [Foundation Models Frameworkとは？Apple基盤モデルの性能・使い方とiOS 27の変更点](/tech/details/9181/)
- [MLXとは？mlx-lmの使い方｜生成・量子化・サーバ・LoRAの手順とApple Siliconでの採用判断【2026年10月】](/tech/details/17956/)
- [ONNXとは？読み方・.onnxファイルの中身・変換とONNX Runtimeでの推論【onnx 1.23／ORT 1.31対応】](/tech/details/7528/)
- [TensorFlow Lite（LiteRT）とは？改称後の位置づけ・モデル変換・NPU実行を実装目線で解説](/tech/details/16870/)

---

出典: [Core MLとは？Create ML・coremltools 9でのモデル作成とSwift推論、Core AIとの使い分け](<https://www.issoh.co.jp/tech/details/7513/>)（株式会社一創）
