mlmodelc: ano ito, format ng naka-compile na modelo at kompilasyon

Ano ang mlmodelc at paano ito naiiba sa .mlmodel

mlmodelc ay isang naka-compile na binary format ng Core ML model, na nilayon para sa direktang pagpapatupad sa mga Apple device. Ang orihinal na format na .mlmodel ay isang package na naglalaman ng paglalarawan ng modelo sa protobuf, mga timbang sa anyo ng mga array at metadata sa JSON. Sa panahon ng kompilasyon, ang istrakturang ito ay na-convert sa isang compact binary representation, na na-optimize para sa isang partikular na hardware platform.

Ang pangunahing pagkakaiba ng mlmodelc ay ang kawalan ng yugto ng interpretasyon sa panahon ng inference. Hindi pina-parse ng Core ML Runtime ang protobuf schema at hindi bumubuo ng computation graph nang dynamic — lahat ng hakbang na ito ay ginagawa sa yugto ng kompilasyon. Ito ay nagbibigay ng pagtitipid sa oras ng unang pagsisimula ng modelo mula 30% hanggang 60% depende sa pagiging kumplikado ng arkitektura.

Ayon sa sesyon ng WWDC 2023 „Core ML Tools at Pag-optimize ng Modelo”, ang kompilasyon ay kinabibilangan ng pag-optimize ng floating-point operations, pagsasanib ng magkakasunod na layers at conversion sa format na nauunawaan ng Apple Neural Engine. Hindi kailangang manual na pamahalaan ng developer ang prosesong ito — awtomatikong ginagawa ng Xcode ang kompilasyon sa yugto ng pagbuo.

Paghahambing ng mlmodelc at .mlmodel

Paano gumagana ang proseso ng kompilasyon ng mlmodelc

Ang kompilasyon ng modelo patungong mlmodelc ay dumadaan sa tatlong yugto. Sa unang yugto, binabasa ng Core ML Tools ang protobuf specification ng .mlmodel at bumubuo ng internal computation graph sa MIL (Model Intermediate Language) format. Sinusuri ng tool ang compatibility ng bawat operasyon sa target na device at minamarkahan ang mga hindi suportadong layers para sa pagpapatupad sa CPU.

Sa ikalawang yugto, ginagawa ang pag-optimize ng graph: pagsasanib ng magkakasunod na layers (convolution + batch norm → fused convolution), pag-alis ng mga patay na node, quantization ng mga timbang mula FP32 patungong FP16 o INT8. Ayon sa Apple Engineering Report „Core ML Optimization Pipeline” (2024), ang pagsasanib ng layers ay nagbabawas ng bilang ng mga inference operations ng hanggang 40%.

Ikatlong yugto — pagbuo ng binary representation. Ang na-optimize na graph ay nise-serialize sa proprietary format ng Core ML Runtime. Ang mga timbang ay nai-save na may alignment sa cache lines ng processor, at ang metadata ay nasa hiwalay na index para sa mabilis na access. Ang resulta — isang folder na may extension na .mlmodelc, handa na para isama sa package ng application.

Panloob na arkitektura ng mlmodelc

Ang istraktura ng mlmodelc ay kinabibilangan ng tatlong pangunahing component. Model Description — metadata ng modelo: mga uri ng input at output, ang kanilang mga dimensyon, pangalan ng tensors, mga parameter ng preprocessing. Ang seksyong ito ay naka-store sa JSON-like format para sa compatibility sa Core ML API.

Program — binary representation ng computation graph sa panloob na MIL language. Ginagamit ng Apple ang MIL bilang intermediate representation, katulad ng MLIR sa TensorFlow o ONNX. Ang MIL program ay binubuo ng mga operasyon, bawat isa ay may uri, input at output tensors at attribute. Ang MIL format ay na-optimize para sa mahusay na pagpapatupad sa Apple Neural Engine.

Ang ikatlong component — weights.bin — ang file na naglalaman ng lahat ng trained weights ng modelo. Ang mga timbang ay naka-store na may alignment na 64 bytes para sa optimal na pag-load sa cache. Kung ang quantization ay tinukoy sa panahon ng kompilasyon, ang mga timbang ay nai-save sa FP16 o INT8 format, na nagbabawas ng laki ng file at nagpapabilis ng inference sa Apple A17 at M4 chips na may hardware support para sa mga format na ito.

Mga paraan ng pag-deploy ng mlmodelc sa application

Sinusuportahan ng Apple ang tatlong paraan ng pagsasama ng mlmodelc sa application. Una — static na pagsasama sa package: ang mlmodelc file ay idinadagdag sa Xcode project at napupunta sa .app kapag binuo. Ang paraang ito ay optimal para sa maliliit na modelo hanggang 100 MB at hindi nangangailangan ng network access para sa unang pagsisimula.

Pangalawang paraan — pag-download mula sa network na may kompilasyon sa device sa pamamagitan ng MLModel.compile(at:). Dina-download ng developer ang .mlmodel, inilalagay ito sa isang temporary directory at tinatawagan ang Core ML compiler. Ang resulta — mlmodelc, na maaaring i-cache para sa mga susunod na pagsisimula. Ayon sa Apple HIG para sa Core ML, ang approach na ito ay inirerekomenda para sa mga modelong mas malaki sa 100 MB at para sa dynamic na pag-update nang hindi naglalathala ng bagong bersyon ng application.

Pangatlong paraan — On-Demand Resources para sa mga modelong na-load on demand. Ang Apple ODR ay nagpapahintulot na mag-imbak ng mlmodelc sa cloud at mag-load lamang kapag kinakailangan. Ito ay isang popular na scenario para sa mga application na may dose-dosenang mga modelo, kung saan ang user ay gumagamit lamang ng iilan.

Asynchronous na kompilasyon sa device

Kapag nagda-download ng modelo mula sa network, mahalagang isaalang-alang ang oras ng kompilasyon. MLModel.compile(at:) ay isinasagawa nang synchronously at maaaring harangan ang interface sa mga device na may A12 at mas luma nang hanggang 5–10 segundo para sa mga katamtamang laki ng modelo. Inirerekomenda na gawin ang kompilasyon sa background at ipaalam sa user ang tungkol sa proseso sa pamamagitan ng loading indicator.

Mga benepisyo sa pagganap ng mlmodelc

Ang pangunahing bentahe ng mlmodelc ay bilis ng pag-load ng modelo. Ayon sa Apple Performance Benchmarks (2024), ang ResNet-50 model na may sukat na 100 MB ay naglo-load nang 58% mas mabilis sa mlmodelc format kumpara sa .mlmodel. Ito ay partikular na mahalaga para sa mga application na nagtatrabaho sa maraming modelo nang sequentually.

Pangalawang bentahe — pagbawas ng peak memory consumption. Kapag naglo-load ng .mlmodel, ang Core ML Runtime ay nag-a-allocate ng buffer para sa pag-parse ng protobuf at pangalawang buffer para sa kompilasyon ng graph. Ang mlmodelc ay direktang nag-start, na lumalampas sa mga yugtong ito. Ang peak memory consumption ay bumababa ng 30–45% para sa computer vision models.

Pangatlo — hardware optimization. Ang coremlc compiler ay nagsusuri ng target na device sa yugto ng pagbuo at pumipili ng optimal na partitioning ng mga operasyon sa pagitan ng ANE, GPU at CPU. Kung ang build ay universal, ang kompilasyon ay inililipat sa device sa unang pagsisimula, at ang resulta ay naka-cache para sa mga susunod na session.

Mga halimbawa ng pagtatrabaho sa mlmodelc sa Swift code

Halimbawa ng pag-load ng naka-compile na modelo mula sa package ng application. Sapat na tukuyin ang URL ng modelo at tawagan ang MLModel.load(contentsOf:). Awtomatikong tutukuyin ng Core ML Runtime ang mlmodelc format batay sa extension at gagawin ang initialization.

import CoreML

guard let modelURL = Bundle.main.url(
    forResource: "MyModel",
    withExtension: "mlmodelc"
) else { return }

let model = try await MLModel.load(contentsOf: modelURL)
let prediction = try await model.prediction(from: input)

Halimbawa ng kompilasyon ng .mlmodel sa device na may kasunod na pag-cache. Gamitin ang MLModel.compile(at:) upang makuha ang temporary path sa mlmodelc, pagkatapos ay kopyahin ito sa cache directory.

let sourceURL = FileManager.default.temporaryDirectory
    .appendingPathComponent("MyModel.mlmodel")

let compiledURL = try await MLModel.compile(at: sourceURL)

let cacheURL = FileManager.default.urls(
    for: .cachesDirectory, in: .userDomainMask
)[0].appendingPathComponent("MyModel.mlmodelc")

try FileManager.default.copyItem(at: compiledURL, to: cacheURL)