Core ML Model Conversion: apa itu, tahapan dan cara konversi

Apa itu Core ML Model Conversion

Core ML Model Conversion adalah proses mengubah model machine learning yang telah dilatih dari format framework asli ke format .mlmodel yang dapat dipahami oleh Core ML Runtime pada perangkat Apple. Tanpa konversi, model yang dilatih di PyTorch atau TensorFlow tidak dapat dimuat dan dijalankan secara langsung di iOS atau macOS.

Proses konversi mencakup penerjemahan grafik komputasi: setiap operator dari framework asli (Conv2D, BatchNorm, ReLU) dipetakan ke operator Core ML yang sesuai. Jika tidak ada pengganti langsung, coremltools menggunakan operasi gabungan atau lapisan kustom. Menurut Apple ML Research, perpustakaan ini mencakup lebih dari 200 operator dari berbagai framework.

Setelah konversi, model disimpan dalam format paket .mlmodel, yang mencakup deskripsi grafik protobuf, bobot dalam bentuk biner, dan metadata. File ini kemudian dikompilasi menjadi mlmodelc untuk dieksekusi pada perangkat target.

Framework dan format yang didukung

coremltools versi 7.x mendukung konversi dari enam sumber. PyTorch — melalui torch.jit.trace atau torch.export, TensorFlow 2.x — melalui SavedModel dan Keras H5, TensorFlow 1.x — melalui frozen graph .pb. Untuk ONNX, digunakan representasi perantara yang kemudian diterjemahkan ke Core ML.

Matriks kompatibilitas framework

Alat konversi: coremltools

coremltools — adalah perpustakaan Python sumber terbuka resmi dari Apple, tersedia melalui pip install coremltools. Perpustakaan ini menyediakan API terpadu untuk konversi dari semua framework yang didukung, serta alat pasca-pemrosesan: kuantisasi, pemeriksaan akurasi, dan visualisasi grafik.

Instalasi dan konversi dasar model dari 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")

Untuk konversi dari TensorFlow, gunakan SavedModel sebagai sumber. coremltools secara otomatis menentukan tensor masukan dan keluaran berdasarkan signature_def:

import coremltools as ct

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

Tahapan konversi model

Proses konversi terdiri dari empat tahap. Pada tahap pertama, coremltools memuat model asli dan melakukan pelacakan (tracing) atau pemindaian grafik. Untuk PyTorch, digunakan torch.jit.trace yang menjalankan data masukan sampel melalui model dan mencatat urutan operasi.

Pada tahap kedua, dilakukan pemetaan operator (operator mapping). Setiap operator dari grafik asli dicocokkan dengan operator Core ML. Jika tidak ada pengganti langsung, coremltools membagi operator menjadi urutan operator yang didukung. Menurut dokumentasi coremltools, cakupan operator PyTorch melebihi 95% untuk arsitektur umum.

Tahap ketiga — optimasi grafik. coremltools melakukan penggabungan operasi (mis., conv + batch norm), penghapusan transformasi yang tidak perlu, dan pengurutan ulang operator untuk meningkatkan efisiensi. Tahap keempat — serialisasi ke format .mlmodel dengan menyimpan bobot dan metadata.

Masalah umum dan solusinya

Masalah paling umum saat konversi adalah operasi yang tidak didukung. Jika model berisi operator yang tidak ada di Core ML, coremltools melaporkan kesalahan dengan nama operasi tersebut. Solusi — ganti operator dengan kombinasi setara dari operator yang didukung atau implementasikan lapisan kustom melalui custom layer API.

Masalah kedua — ketidakcocokan dimensi. PyTorch menggunakan format NCHW, sedangkan Core ML secara default menggunakan NHWC. coremltools secara otomatis menyisipkan transposisi, tetapi terkadang urutan sumbu ditentukan secara tidak benar. Periksa dimensi masukan dan keluaran di log konversi dan jika perlu, tentukan input_features dengan nama yang benar.

Masalah ketiga — kehilangan akurasi setelah kuantisasi. Saat konversi dengan palet FP16 atau INT8, akurasi model dapat menurun. coremltools menyediakan utilitas ct.models.CompiledModel untuk membandingkan keluaran model asli dan yang telah dikonversi pada data masukan yang sama. Jika perbedaan melebihi 1%, gunakan kuantisasi dengan palet FP16 tanpa kalibrasi atau hentikan kuantisasi.

Contoh konversi dari PyTorch dan TensorFlow

Contoh konversi model MobileNetV3 dari PyTorch dengan menentukan tipe data masukan dan versi iOS minimum. Gunakan ct.ImageType untuk normalisasi gambar otomatis:

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
)

# Simpan ke .mlmodel untuk kompilasi nanti di Xcode
mlmodel.save("MobileNetV3.mlmodel")

Contoh konversi dari TensorFlow Keras dengan kuantisasi FP16. Tentukan minimum_deployment_target untuk mengaktifkan dukungan FP16 pada perangkat Apple A13 dan yang lebih baru:

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
)

# Kuantisasi bobot ke FP16 untuk pengurangan ukuran 2x
mlmodel_fp16 = ct.models.neural_network.quantization_utils.quantize_weights(
    mlmodel, 16
)
mlmodel_fp16.save("EfficientNetB0_fp16.mlmodel")