Core ML Model Conversion: ano ito, mga yugto at paraan ng conversion

Ano ang Core ML Model Conversion

Core ML Model Conversion ay ang proseso ng pag-convert ng isang sinanay na modelo ng machine learning mula sa orihinal na format ng framework patungo sa format na .mlmodel na naiintindihan ng Core ML Runtime sa mga Apple device. Kung walang conversion, ang modelong sinanay sa PyTorch o TensorFlow ay hindi maaaring direktang i-load at patakbuhin sa iOS o macOS.

Ang proseso ng conversion ay may kasamang pagsasalin ng computational graph: bawat operator ng orihinal na framework (Conv2D, BatchNorm, ReLU) ay na-map sa kaukulang operator ng Core ML. Kung walang direktang kapalit, ang coremltools ay gumagamit ng pinagsamang operasyon o custom na layer. Ayon sa Apple ML Research, ang library ay sumasaklaw ng higit sa 200 operator mula sa iba’t ibang framework.

Pagkatapos ng conversion, ang modelo ay nai-save sa .mlmodel package format, na may kasamang protobuf na paglalarawan ng grap, mga timbang sa binary form, at metadata. Ang file na ito ay pagkatapos ay compile sa mlmodelc para sa pagpapatupad sa target na device.

Mga sinusuportahang framework at format

Ang coremltools bersyon 7.x ay sumusuporta sa conversion mula sa anim na pinagmulan. PyTorch — sa pamamagitan ng torch.jit.trace o torch.export, TensorFlow 2.x — sa pamamagitan ng SavedModel at Keras H5, TensorFlow 1.x — sa pamamagitan ng frozen graph .pb. Para sa ONNX, ginagamit ang intermediate na representasyon na pagkatapos ay isasalin sa Core ML.

Matrix ng compatibility ng framework

Mga kasangkapan sa conversion: coremltools

Ang coremltools — ay ang opisyal na open-source na Python library mula sa Apple, na available sa pamamagitan ng pip install coremltools. Ang library ay nagbibigay ng nagkakaisang API para sa conversion mula sa lahat ng sinusuportahang framework, pati na rin ang mga kasangkapan para sa post-processing: quantization, pagsusuri ng accuracy, at visualization ng grap.

Pag-install at pangunahing conversion ng modelo mula sa 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")

Para sa conversion mula sa TensorFlow, gamitin ang SavedModel bilang pinagmulan. Awtomatikong tinutukoy ng coremltools ang input at output tensor batay sa signature_def:

import coremltools as ct

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

Mga yugto ng conversion ng modelo

Ang proseso ng conversion ay binubuo ng apat na yugto. Sa unang yugto, ini-load ng coremltools ang orihinal na modelo at nagsasagawa ng pagtunton (tracing) o pag-scan ng grap. Para sa PyTorch, ginagamit ang torch.jit.trace na nagpapasa ng sample na input data sa modelo at nagtatala ng pagkakasunod-sunod ng mga operasyon.

Sa ikalawang yugto, isinasagawa ang pagmamapa ng operator (operator mapping). Bawat operator mula sa orihinal na grap ay itinutugma sa operator ng Core ML. Kung walang direktang kapalit, hinahati ng coremltools ang operator sa isang pagkakasunod-sunod ng mga suportadong operator. Ayon sa dokumentasyon ng coremltools, ang saklaw ng operator ng PyTorch ay lumalampas sa 95% para sa karaniwang mga arkitektura.

Ikatlong yugto — pag-optimize ng grap. Ang coremltools ay nagsasagawa ng pagsasama ng operasyon (hal., conv + batch norm), pag-alis ng hindi kinakailangang pagbabago, at muling pag-aayos ng mga operator para sa pagtaas ng kahusayan. Ikaapat na yugto — serialization sa format na .mlmodel na may pagpapanatili ng mga timbang at metadata.

Mga karaniwang problema at solusyon

Ang pinakakaraniwang problema sa conversion ay ang mga hindi suportadong operasyon. Kung ang modelo ay naglalaman ng operator na wala sa Core ML, ang coremltools ay nag-uulat ng error na may pangalan ng operasyon. Solusyon — palitan ang operator ng katumbas na kumbinasyon ng mga suportadong operator o ipatupad ang custom na layer sa pamamagitan ng custom layer API.

Pangalawang problema — hindi pagkakatugma ng dimensyon. Ang PyTorch ay gumagamit ng NCHW format, habang ang Core ML ay default na gumagamit ng NHWC. Awtomatikong naglalagay ang coremltools ng transposisyon, ngunit minsan ang pagkakasunod-sunod ng mga axis ay natutukoy nang hindi tama. Suriin ang mga input at output na dimensyon sa mga log ng conversion at kung kinakailangan, tukuyin ang input_features na may tamang mga pangalan.

Pangatlong problema — pagkawala ng accuracy pagkatapos ng quantization. Sa conversion na may FP16 o INT8 na palette, ang accuracy ng modelo ay maaaring bumaba. Nagbibigay ang coremltools ng utility na ct.models.CompiledModel para sa paghahambing ng mga output ng orihinal at na-convert na modelo sa parehong input data. Kung ang pagkakaiba ay lumampas sa 1%, gamitin ang quantization na may FP16 palette nang walang calibration o itigil ang quantization.

Mga halimbawa ng conversion mula sa PyTorch at TensorFlow

Halimbawa ng conversion ng modelong MobileNetV3 mula sa PyTorch na may pagtukoy sa uri ng input data at minimum na bersyon ng iOS. Gamitin ang ct.ImageType para sa awtomatikong normalisasyon ng mga larawan:

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
)

# I-save sa .mlmodel para sa susunod na compilation sa Xcode
mlmodel.save("MobileNetV3.mlmodel")

Halimbawa ng conversion mula sa TensorFlow Keras na may FP16 quantization. Tukuyin ang minimum_deployment_target para i-activate ang suporta sa FP16 sa mga device na may Apple A13 at mas bago:

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
)

# I-quantize ang mga timbang sa FP16 para sa 2x na pagbawas ng laki
mlmodel_fp16 = ct.models.neural_network.quantization_utils.quantize_weights(
    mlmodel, 16
)
mlmodel_fp16.save("EfficientNetB0_fp16.mlmodel")