Core ML Model Conversion: vad det är, steg och konverteringsmetoder

Vad är Core ML Model Conversion

Core ML Model Conversion är processen att omvandla en tränad maskininlärningsmodell från det ursprungliga ramverkets format till .mlmodel-formatet som är förståeligt för Core ML Runtime på Apple-enheter. Utan konvertering kan en modell tränad i PyTorch eller TensorFlow inte laddas och köras direkt på iOS eller macOS.

Konverteringsprocessen inkluderar översättning av beräkningsgrafen: varje operator i det ursprungliga ramverket (Conv2D, BatchNorm, ReLU) mappas till motsvarande Core ML-operator. Om det inte finns någon direkt ersättning använder coremltools sammansatta operationer eller anpassade lager. Enligt Apple ML Research täcker biblioteket över 200 operatorer från olika ramverk.

Efter konvertering sparas modellen i .mlmodel-paketformat, som inkluderar en protobuf-beskrivning av grafen, vikter i binär form och metadata. Denna fil kompileras sedan till mlmodelc för exekvering på målenheten.

Stödda ramverk och format

coremltools version 7.x stöder konvertering från sex källor. PyTorch — via torch.jit.trace eller torch.export, TensorFlow 2.x — via SavedModel och Keras H5, TensorFlow 1.x — via frozen graph .pb. För ONNX används en mellanliggande representation som sedan översätts till Core ML.

Ramverkskompatibilitetsmatris

Konverteringsverktyg: coremltools

coremltools — är Apples officiella öppen källkods Python-bibliotek, tillgängligt via pip install coremltools. Biblioteket erbjuder ett enhetligt API för konvertering från alla stödda ramverk, samt verktyg för efterbearbetning: kvantisering, noggrannhetskontroll och grafvisualisering.

Installation och grundläggande konvertering av modell från 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 konvertering från TensorFlow, använd SavedModel som källa. coremltools bestämmer automatiskt in- och utdatatensorer baserat på signature_def:

import coremltools as ct

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

Steg för modellkonvertering

Konverteringsprocessen består av fyra steg. I första steget laddar coremltools originalmodellen och utför spårning (tracing) eller granskning av grafen. För PyTorch används torch.jit.trace, som kör exempelindata genom modellen och registrerar operationssekvensen.

I det andra steget utförs operatormappning (operator mapping). Varje operator från originalgrafen kopplas till en Core ML-operator. Om det inte finns någon direkt ersättning delar coremltools upp operatorn i en sekvens av stödda operatorer. Enligt coremltools-dokumentationen överstiger täckningen av PyTorch-operatorer 95% för typiska arkitekturer.

Tredje steget — grafoptimering. coremltools utför sammanslagning av operationer (t.ex. conv + batch norm), borttagning av onödiga transformationer och omordning av operatorer för ökad effektivitet. Fjärde steget — serialisering till .mlmodel-format med bevarande av vikter och metadata.

Vanliga problem och deras lösningar

Det vanligaste problemet vid konvertering är ej stödda operationer. Om modellen innehåller en operator som saknas i Core ML rapporterar coremltools ett fel med operatörens namn. Lösning — ersätt operatorn med en ekvivalent kombination av stödda operatorer eller implementera ett anpassat lager via custom layer API.

Andra problemet — dimensionsmismatch. PyTorch använder NCHW-formatet medan Core ML som standard använder NHWC. coremltools infogar automatiskt transponering, men ibland bestäms axelordningen felaktigt. Kontrollera in- och utdatadimensionerna i konverteringsloggarna och ange vid behov input_features med korrekta namn.

Tredje problemet — noggrannhetsförlust efter kvantisering. Vid konvertering med FP16- eller INT8-palett kan modellens noggrannhet minska. coremltools tillhandahåller verktyget ct.models.CompiledModel för att jämföra utdata från original- och konverterad modell på samma indata. Om skillnaden överstiger 1%, använd kvantisering med FP16-palett utan kalibrering eller avstå från kvantisering.

Exempel på konvertering från PyTorch och TensorFlow

Exempel på konvertering av MobileNetV3-modellen från PyTorch med angivelse av indatatyp och lägsta iOS-version. Använd ct.ImageType för automatisk normalisering av bilder:

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
)

# Spara till .mlmodel för senare kompilering i Xcode
mlmodel.save("MobileNetV3.mlmodel")

Exempel på konvertering från TensorFlow Keras med FP16-kvantisering. Ange minimum_deployment_target för att aktivera FP16-stöd på enheter med Apple A13 och nyare:

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
)

# Kvantisera vikter till FP16 för 2x storleksminskning
mlmodel_fp16 = ct.models.neural_network.quantization_utils.quantize_weights(
    mlmodel, 16
)
mlmodel_fp16.save("EfficientNetB0_fp16.mlmodel")