Core ML Model Conversion: co to jest, etapy i metody konwersji

Co to jest Core ML Model Conversion

Core ML Model Conversion — to proces przekształcania wytrenowanego modelu uczenia maszynowego z formatu oryginalnego frameworku do formatu .mlmodel, zrozumiałego dla Core ML Runtime na urządzeniach Apple. Bez konwersji model wytrenowany w PyTorch lub TensorFlow nie może być bezpośrednio załadowany i wykonany na iOS lub macOS.

Proces konwersji obejmuje translację grafu obliczeń: każdy operator oryginalnego frameworku (Conv2D, BatchNorm, ReLU) jest mapowany na odpowiedni operator Core ML. Jeśli nie ma bezpośredniego zamiennika, coremltools używa operacji złożonych lub niestandardowych warstw. Według Apple ML Research, biblioteka pokrywa ponad 200 operatorów z różnych frameworków.

Po konwersji model zapisywany jest w formacie pakietu .mlmodel, który zawiera opis grafu w protobuf, wagi w formie binarnej i metadane. Ten plik jest następnie kompilowany do mlmodelc do wykonywania na urządzeniu docelowym.

Obsługiwane frameworki i formaty

coremltools w wersji 7.x obsługuje konwersję z sześciu źródeł. PyTorch — przez torch.jit.trace lub torch.export, TensorFlow 2.x — przez SavedModel i Keras H5, TensorFlow 1.x — przez frozen graph .pb. Dla ONNX używane jest pośrednie przedstawienie, które jest następnie translowane do Core ML.

Macierz kompatybilności frameworków

Narzędzia konwersji: coremltools

coremltools — to oficjalna biblioteka Python od Apple z otwartym kodem źródłowym, dostępna przez pip install coremltools. Biblioteka zapewnia jednolite API do konwersji ze wszystkich obsługiwanych frameworków, a także narzędzia do post-processingu: kwantyzację, sprawdzanie dokładności i wizualizację grafu.

Instalacja i podstawowa konwersja modelu z 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")

Do konwersji z TensorFlow użyj SavedModel jako źródła. coremltools automatycznie określa wejściowe i wyjściowe tensory na podstawie signature_def:

import coremltools as ct

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

Etapy konwersji modelu

Proces konwersji składa się z czterech etapów. W pierwszym etapie coremltools ładuje oryginalny model i wykonuje trasowanie (tracing) lub skanowanie grafu. Dla PyTorch używane jest torch.jit.trace, które przepuszcza przykładowe dane wejściowe przez model i zapisuje sekwencję operacji.

W drugim etapie wykonywane jest mapowanie operatorów (operator mapping). Każdy operator z oryginalnego grafu jest dopasowywany do operatora Core ML. Jeśli nie ma bezpośredniego zamiennika, coremltools dzieli operator na sekwencję obsługiwanych. Według dokumentacji coremltools, pokrycie operatorów PyTorch przekracza 95% dla typowych architektur.

Trzeci etap — optymalizacja grafu. coremltools wykonuje łączenie operacji (np. conv + batch norm), usuwanie zbędnych przekształceń i zmianę kolejności operatorów w celu zwiększenia wydajności. Czwarty etap — serializacja do formatu .mlmodel z zachowaniem wag i metadanych.

Typowe problemy i ich rozwiązania

Najczęstszym problemem podczas konwersji są nieobsługiwane operacje. Jeśli model zawiera operator, którego brakuje w Core ML, coremltools zgłasza błąd z nazwą operacji. Rozwiązanie — zastąp operator równoważną kombinacją obsługiwanych lub zaimplementuj niestandardową warstwę przez custom layer API.

Drugi problem — niezgodność wymiarów. PyTorch używa formatu NCHW, a Core ML domyślnie NHWC. coremltools automatycznie wstawia transpozycję, ale czasami kolejność osi jest określana nieprawidłowo. Sprawdź wejściowe i wyjściowe wymiary w logach konwersji i w razie potrzeby podaj input_features z prawidłowymi nazwami.

Trzeci problem — utrata precyzji po kwantyzacji. Podczas konwersji z paletą FP16 lub INT8 precyzja modelu może się zmniejszyć. coremltools udostępnia narzędzie ct.models.CompiledModel do porównywania wyjść oryginalnego i skonwertowanego modelu na tych samych danych wejściowych. Jeśli różnica przekracza 1%, użyj kwantyzacji z paletą FP16 bez kalibracji lub zrezygnuj z kwantyzacji.

Przykłady konwersji z PyTorch i TensorFlow

Przykład konwersji modelu MobileNetV3 z PyTorch z podaniem typu danych wejściowych i minimalnej wersji iOS. Użyj ct.ImageType do automatycznej normalizacji obrazów:

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
)

# Zapisz do .mlmodel do późniejszej kompilacji w Xcode
mlmodel.save("MobileNetV3.mlmodel")

Przykład konwersji z TensorFlow Keras z kwantyzacją FP16. Podaj minimum_deployment_target, aby włączyć obsługę FP16 na urządzeniach z Apple A13 i nowszych:

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
)

# Kwantyzuj wagi do FP16, aby zmniejszyć rozmiar 2-krotnie
mlmodel_fp16 = ct.models.neural_network.quantization_utils.quantize_weights(
    mlmodel, 16
)
mlmodel_fp16.save("EfficientNetB0_fp16.mlmodel")