Core ML Model Conversion: wat het is, fasen en conversiemethoden

Wat is Core ML Model Conversion

Core ML Model Conversion is het proces van het omzetten van een getraind machine learning-model van het oorspronkelijke frameworkformaat naar het .mlmodel-formaat dat begrijpelijk is voor Core ML Runtime op Apple-apparaten. Zonder conversie kan een model dat is getraind in PyTorch of TensorFlow niet direct worden geladen en uitgevoerd op iOS of macOS.

Het conversieproces omvat vertaling van de berekeningsgrafiek: elke operator van het oorspronkelijke framework (Conv2D, BatchNorm, ReLU) wordt toegewezen aan de overeenkomstige Core ML-operator. Als er geen directe vervanging is, gebruikt coremltools samengestelde bewerkingen of aangepaste lagen. Volgens Apple ML Research dekt de bibliotheek meer dan 200 operators uit verschillende frameworks.

Na conversie wordt het model opgeslagen in het .mlmodel-pakketformaat, dat een protobuf-beschrijving van de grafiek, gewichten in binaire vorm en metadata bevat. Dit bestand wordt vervolgens gecompileerd naar mlmodelc voor uitvoering op het doelapparaat.

Ondersteunde frameworks en formaten

coremltools versie 7.x ondersteunt conversie uit zes bronnen. PyTorch — via torch.jit.trace of torch.export, TensorFlow 2.x — via SavedModel en Keras H5, TensorFlow 1.x — via frozen graph .pb. Voor ONNX wordt een tussenliggende representatie gebruikt die vervolgens naar Core ML wordt vertaald.

Framework-compatibiliteitsmatrix

Conversietools: coremltools

coremltools — is de officiële open-source Python-bibliotheek van Apple, beschikbaar via pip install coremltools. De bibliotheek biedt een uniforme API voor conversie uit alle ondersteunde frameworks, evenals tools voor nabewerking: kwantisatie, nauwkeurigheidscontrole en grafiekvisualisatie.

Installatie en basisconversie van een model uit 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")

Gebruik voor conversie uit TensorFlow SavedModel als bron. coremltools bepaalt automatisch de in- en uitvoertensoren op basis van signature_def:

import coremltools as ct

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

Fasen van modelconversie

Het conversieproces bestaat uit vier fasen. In de eerste fase laadt coremltools het originele model en voert tracering (tracing) of scannen van de grafiek uit. Voor PyTorch wordt torch.jit.trace gebruikt, dat voorbeeldinvoergegevens door het model laat lopen en de volgorde van bewerkingen vastlegt.

In de tweede fase wordt operatortoewijzing (operator mapping) uitgevoerd. Elke operator uit de originele grafiek wordt gekoppeld aan een Core ML-operator. Als er geen directe vervanging is, splitst coremltools de operator in een reeks ondersteunde operators. Volgens de coremltools-documentatie bedekt de PyTorch-operator dekking meer dan 95% voor typische architecturen.

Derde fase — grafiekoptimalisatie. coremltools voert het samenvoegen van bewerkingen (bijv. conv + batch norm), het verwijderen van overbodige transformaties en het herordenen van operators uit voor efficiëntieverbetering. Vierde fase — serialisatie naar .mlmodel-formaat met behoud van gewichten en metadata.

Veelvoorkomende problemen en oplossingen

Het meest voorkomende probleem bij conversie zijn niet-ondersteunde bewerkingen. Als het model een operator bevat die ontbreekt in Core ML, rapporteert coremltools een fout met de naam van de bewerking. Oplossing — vervang de operator door een equivalente combinatie van ondersteunde operators of implementeer een aangepaste laag via custom layer API.

Tweede probleem — dimensionale mismatch. PyTorch gebruikt het NCHW-formaat, terwijl Core ML standaard NHWC gebruikt. coremltools voegt automatisch transpositie in, maar soms wordt de asvolgorde verkeerd bepaald. Controleer de in- en uitvoerdimensies in de conversielogboeken en specificeer indien nodig input_features met de juiste namen.

Derde probleem — nauwkeurigheidsverlies na kwantisatie. Bij conversie met FP16- of INT8-palet kan de nauwkeurigheid van het model afnemen. coremltools biedt het hulpprogramma ct.models.CompiledModel voor het vergelijken van uitvoer van het originele en geconverteerde model op dezelfde invoergegevens. Als het verschil meer dan 1% bedraagt, gebruik dan kwantisatie met FP16-palet zonder kalibratie of zie af van kwantisatie.

Voorbeelden van conversie uit PyTorch en TensorFlow

Voorbeeld van conversie van het MobileNetV3-model uit PyTorch met specificatie van het invoergegevenstype en minimale iOS-versie. Gebruik ct.ImageType voor automatische normalisatie van afbeeldingen:

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
)

# Opslaan naar .mlmodel voor latere compilatie in Xcode
mlmodel.save("MobileNetV3.mlmodel")

Voorbeeld van conversie uit TensorFlow Keras met FP16-kwantisatie. Specificeer minimum_deployment_target om FP16-ondersteuning in te schakelen op apparaten met Apple A13 en nieuwer:

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
)

# Kwantiseer gewichten naar FP16 voor 2x groottevermindering
mlmodel_fp16 = ct.models.neural_network.quantization_utils.quantize_weights(
    mlmodel, 16
)
mlmodel_fp16.save("EfficientNetB0_fp16.mlmodel")