Core ML-Modellkonvertierung: Was es ist, Schritte und Methoden der Konvertierung

Was ist Core ML Model Conversion

Core ML Model Conversion ist der Prozess der Umwandlung eines trainierten Machine-Learning-Modells aus dem Quell-Framework-Format in das .mlmodel-Format, das von Core ML Runtime auf Apple-Geräten verstanden wird. Ohne Konvertierung kann ein in PyTorch oder TensorFlow trainiertes Modell nicht direkt auf iOS oder macOS geladen und ausgeführt werden.

Der Konvertierungsprozess umfasst die Übersetzung des Berechnungsgraphen: Jeder Operator des Quell-Frameworks (Conv2D, BatchNorm, ReLU) wird dem entsprechenden Core ML-Operator zugeordnet. Wenn kein direkter Ersatz existiert, verwendet coremltools zusammengesetzte Operationen oder benutzerdefinierte Schichten. Laut Apple ML Research deckt die Bibliothek über 200 Operatoren aus verschiedenen Frameworks ab.

Nach der Konvertierung wird das Modell im .mlmodel-Bundle-Format gespeichert, das eine Protobuf-Graphbeschreibung, Gewichte in binärer Form und Metadaten enthält. Diese Datei wird dann zur Ausführung auf dem Zielgerät in mlmodelc kompiliert.

Unterstützte Frameworks und Formate

coremltools Version 7.x unterstützt die Konvertierung aus sechs Quellen. PyTorch — über torch.jit.trace oder torch.export, TensorFlow 2.x — über SavedModel und Keras H5, TensorFlow 1.x — über Frozen Graph .pb. Für ONNX wird eine Zwischendarstellung verwendet, die dann in Core ML übersetzt wird.

Framework-Kompatibilitätsmatrix

Konvertierungswerkzeuge: coremltools

coremltools ist die offizielle Open-Source-Python-Bibliothek von Apple, verfügbar über pip install coremltools. Die Bibliothek bietet eine einheitliche API zur Konvertierung aus allen unterstützten Frameworks sowie Nachbearbeitungswerkzeuge: Quantisierung, Genauigkeitsprüfung und Graphvisualisierung.

Installation und grundlegende Modellkonvertierung aus PyTorch:

import coremltools as ct
import torch
import torchvision

model = torchvision.models.resnet18(pretrained=True)
model.eval()

example_input = torch.rand(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

mlmodel = ct.convert(
    traced_model,
    source="pytorch",
    inputs=[ct.ImageType(shape=example_input.shape)]
)
mlmodel.save("ResNet18.mlmodel")

Für die Konvertierung aus TensorFlow verwenden Sie SavedModel als Quelle. coremltools ermittelt automatisch die Eingabe- und Ausgabetensoren basierend auf signature_def:

import coremltools as ct

mlmodel = ct.convert(
    "saved_model_dir",
    source="tensorflow",
    @minimum_deployment_target=ct.target.iOS16
)
mlmodel.save("MyTFModel.mlmodel")

Schritte der Modellkonvertierung

Der Konvertierungsprozess besteht aus vier Schritten. Im ersten Schritt lädt coremltools das Quellmodell und führt Tracing oder Graph-Scanning durch. Für PyTorch wird torch.jit.trace verwendet, das eine Beispiel-Eingabe durch das Modell laufen lässt und die Operationssequenz aufzeichnet.

Im zweiten Schritt wird das Operator-Mapping durchgeführt. Jeder Operator aus dem Quellgraphen wird einem Core ML-Operator zugeordnet. Wenn kein direkter Ersatz existiert, teilt coremltools den Operator in eine Sequenz unterstützter Operatoren auf. Laut der coremltools-Dokumentation übersteigt die PyTorch-Operatorabdeckung 95% für typische Architekturen.

Der dritte Schritt ist die Graphoptimierung. coremltools führt Operationsfusion (z. B. conv + batch norm), Entfernung unnötiger Transformationen und Neuordnung von Operatoren zur Effizienzsteigerung durch. Der vierte Schritt ist die Serialisierung in das .mlmodel-Format unter Beibehaltung von Gewichten und Metadaten.

Häufige Probleme und deren Lösungen

Das häufigste Problem bei der Konvertierung sind nicht unterstützte Operationen Wenn das Modell einen in Core ML fehlenden Operator enthält, meldet coremltools einen Fehler mit dem Operationsnamen. Die Lösung besteht darin, den Operator durch eine äquivalente Kombination unterstützter Operatoren zu ersetzen oder eine benutzerdefinierte Schicht über die Custom Layer API zu implementieren.

Das zweite Problem ist die Dimensionsdiskrepanz. PyTorch verwendet das NCHW-Format, während Core ML standardmäßig NHWC verwendet. coremltools fügt automatisch eine Transposition ein, aber manchmal wird die Achsenreihenfolge falsch bestimmt. Überprüfen Sie die Ein- und Ausgabedimensionen in den Konvertierungsprotokollen und geben Sie gegebenenfalls input_features mit korrekten Namen an.

Das dritte Problem ist der Genauigkeitsverlust nach der Quantisierung. Bei der Konvertierung mit FP16- oder INT8-Palette kann die Modellgenauigkeit abnehmen. coremltools bietet das Dienstprogramm ct.models.CompiledModel zum Vergleich der Ausgaben des Quell- und des konvertierten Modells bei denselben Eingabedaten. Wenn die Abweichung 1% übersteigt, verwenden Sie die Quantisierung mit FP16-Palette ohne Kalibrierung oder verzichten Sie ganz auf die Quantisierung.

Konvertierungsbeispiele aus PyTorch und TensorFlow

Ein Beispiel für die Konvertierung des MobileNetV3-Modells aus PyTorch mit Angabe des Eingabetyps und der Mindest-iOS-Version. Verwenden Sie ct.ImageType für die automatische Bildnormalisierung:

import coremltools as ct
import torchvision

model = torchvision.models.mobilenet_v3_small(
    pretrained=True
)
model.eval()
example = torch.rand(1, 3, 224, 224)
traced = torch.jit.trace(model, example)

mlmodel = ct.convert(
    traced,
    source="pytorch",
    inputs=[ct.ImageType(
        shape=example.shape,
        scale=1.0/255.0,
        bias=[0, 0, 0]
    )],
    @minimum_deployment_target=ct.target.iOS16
)

# In .mlmodel speichern für spätere Kompilierung in Xcode
mlmodel.save("MobileNetV3.mlmodel")

Ein Beispiel für die Konvertierung aus TensorFlow Keras mit FP16-Quantisierung. Geben Sie minimum_deployment_target an, um FP16-Unterstützung auf Geräten mit Apple A13 und neuer zu aktivieren:

import coremltools as ct
from tensorflow import keras

keras_model = keras.applications.EfficientNetB0(
    weights="imagenet"
)

mlmodel = ct.convert(
    keras_model,
    source="tensorflow",
    @minimum_deployment_target=ct.target.iOS17
)

# Gewichte auf FP16 quantisieren für 2-fache Größenreduzierung
mlmodel_fp16 = ct.models.neural_network.quantization_utils.quantize_weights(
    mlmodel, 16
)
mlmodel_fp16.save("EfficientNetB0_fp16.mlmodel")