Core ML — ano ito, modelo ng machine learning at paggana sa iOS

Ano ang Core ML?

Core ML — ay isang machine learning framework na ipinakilala ng Apple sa WWDC 2017 bilang bahagi ng development ecosystem para sa iPhone, iPad, Mac, Apple Watch at Apple TV. Ang Core ML ay nagbibigay ng runtime para sa pagpapatakbo ng ML models sa device, na nag-aabstrak sa developer mula sa mga detalye ng hardware optimization. Awtomatikong pinipili ng framework ang pinakamahusay na compute engine — Neural Engine sa A12+ chips, GPU o CPU — para sa bawat operasyon ng model.

Pangunahing bentahe ng Core ML — malalim na integration sa Apple Silicon. Ang neural network operations ay isinasagawa sa dedikadong Neural Engine na hindi naglo-load sa mga pangunahing core ng processor. Ayon sa Apple (WWDC 2025), ang Core ML models ay gumagana nang 6 na beses na mas mabilis kumpara sa TensorFlow Lite sa mga katulad na Android device.

Mga pangunahing kakayahan

Core ML ay sumusuporta sa malawak na hanay ng machine learning tasks: image classification, object detection, semantic segmentation, natural language processing, sound analysis at tabular data. Ang framework ay gumagana sa iba't ibang uri ng models: neural networks (convolutional, recurrent, transformers), tree ensembles, linear regressions at Gaussian processes.

Paano gumagana ang Core ML

Core ML ay tumatanggap ng trained model sa .mlpackage format bilang input, ini-compile ito sa na-optimize na machine code para sa partikular na device at pinapatakbo ang inference sa pamamagitan ng unified API. Ang buong pipeline — mula sa pag-load ng model hanggang sa pagkuha ng resulta — ay nangangailangan ng 3–5 linya ng code sa Swift.

Format ng model na .mlpackage

.mlpackage — ay isang container format, na ipinakilala ng Apple noong 2020 upang palitan ang lumang .mlmodel. Ang package ay isang directory na may JSON manifest, model file sa binary MLProgram format, metadata (author, version, description) at resources tulad ng class labels. Ayon sa Apple, binabawasan ng .mlpackage ang laki ng model ng 30–50% kumpara sa .mlmodel dahil sa optimization ng weights.

Apple Neural Engine

Apple Neural Engine (ANE) — dedikadong neuroprocessor na naka-embed sa Apple chips simula sa A12 Bionic (2018). Ang ANE ay nagpoproseso ng matrix operations nang sampung beses na mas efficient kaysa sa CPU sa parehong power consumption. Ang ANE performance ay lumago mula 5 TOPS sa A12 hanggang 35 TOPS sa M4 Ultra (2025), na nagpapahintulot sa pagpapatakbo ng models na may bilyong parameter. Ang ANE ay awtomatikong ginagamit para sa lahat ng Core ML models na may neural network architecture.

Mahalagang feature ng Core ML — suporta para sa quantization ng models sa FP16 at INT8 nang walang pagkawala ng accuracy. Ang quantization ay nagpapaliit ng laki ng model ng 2–4 beses at nagpapabilis ng inference ng 40–60% sa ANE. Ang Apple ay nagbibigay ng tool na Xcode Model Quantization para sa awtomatikong pagpili ng optimal precision: nilo-load ng developer ang model, tinutukoy ang pinapayagang pagkawala ng kalidad (karaniwang 0.1–0.5%), at pinipili ng Xcode ang pinakamahusay na format ng weight representation.

Paghahambing ng performance ng Core ML

Pag-convert ng models sa Core ML

Karamihan ng ML models ay ginagawa sa PyTorch o TensorFlow at nangangailangan ng conversion sa .mlpackage format para magamit sa Core ML. Ang Apple ay nagbibigay ng tool na coremltools — Python package para sa conversion, optimization at validation ng models.

Tool na coremltools

coremltools — ay ang opisyal na tool ng Apple para sa pag-convert ng ML models. Sinusuportahan nito ang import mula sa PyTorch (sa pamamagitan ng torch.onnx o direkta), TensorFlow (SavedModel, H5, Frozen Graph) at ONNX. Pagkatapos ng conversion, maaaring i-activate ang FP16 o INT8 quantization, na nagpapaliit ng laki ng model ng 2–4 beses nang walang makabuluhang pagkawala ng accuracy.

Halimbawa ng conversion mula PyTorch

Tingnan natin ang conversion ng isang trained PyTorch model sa Core ML format gamit ang coremltools bersyon 8.0. Ang proseso ay nangangailangan ng 2–3 hakbang sa Python.

import torch
import coremltools as ct

# Pag-load ng trained PyTorch model
model = torch.load('model.pth')
model.eval()

# Pag-trace ng model gamit ang sample input
example_input = torch.randn(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

# Conversion sa Core ML .mlpackage
mlmodel = ct.convert(
    traced_model,
    convert_to='mlprogram',
    inputs=[ct.TensorType(shape=(1, 3, 224, 224))]
)
mlmodel.save('Model.mlpackage')

Ang code ay naglo-load ng trained PyTorch model, nagsasagawa ng JIT-tracing gamit ang sample input at kino-convert ito sa mlprogram format (binary Core ML format). Ang resultang .mlpackage ay maaaring i-drag sa Xcode at agad na gamitin sa Swift code.

Pagsasama ng Core ML sa iOS app

Pagkatapos ng conversion ng model, ang integration nito sa iOS app sa Swift ay ginagawa sa ilang linya. Awtomatikong bumubuo ang Xcode ng Swift class para sa model batay sa .mlpackage metadata.

Halimbawa ng Swift code

Tingnan natin ang halimbawa ng image classification gamit ang Core ML at Vision framework. Awtomatikong kino-convert ng Vision ang imahe sa kinakailangang laki at pixel format.

import CoreML
import Vision

// Pag-load ng Core ML model
guard let model = try? VNCoreMLModel(
    for: MobileNetV2.configuration.model
) else { return }

// Paglikha ng VNCoreMLRequest
let request = VNCoreMLRequest(model: model) { request, error in
    guard let results = request.results
        as? [VNClassificationObservation]
    else { return }

    // Pag-output ng top-3 predictions
    for result in results.prefix(3) {
        print("\(result.identifier):
              \(result.confidence)")
    }
}

// Pagsisimula ng image processing
let handler = VNImageRequestHandler(
    url: imageURL
)
try? handler.perform([request])

Ang Swift code ay naglo-load ng MobileNetV2 model sa pamamagitan ng Vision framework, lumikha ng classification request at nagpoproseso ng resulta — array ng VNClassificationObservation objects na may class labels at confidence sa porsyento. Ang buong pipeline mula sa pag-load hanggang sa resulta ay tumatagal ng 5–50 ms depende sa model.

Para sa optimization ng startup time, ini-compile ng Core ML ang model sa unang paggamit. Ang pre-compilation (precompiled model) ay nagbabawas ng cold start mula 2–3 segundo hanggang 100–200 ms. Inirerekomenda na gawin ang model compilation sa build stage sa Xcode, hindi sa unang paglunsad ng app. Ito ay lalong mahalaga para sa apps na may maraming ML models — halimbawa, object detection + classification + NLP.

Core ML vs ML Kit

Core ML at ML Kit ay lumulutas ng mga katulad na on-device ML tasks, ngunit nakatuon sa iba't ibang ecosystem. Ang Core ML ay malalim na integrated sa Apple Silicon at sumusuporta lamang sa Apple platforms. Ang ML Kit mula sa Google ay cross-platform solution para sa Android at iOS.

Piliin ang Core ML kung ang iyong ecosystem ay eksklusibong Apple at kailangan mo ng maximum performance sa pamamagitan ng ANE. Kung kinakailangan ang cross-platform o ready API nang walang conversion — mas praktikal ang ML Kit.

Sa praktika, maraming proyekto ang gumagamit ng parehong frameworks: sa iOS Core ML para sa mataas na performance, at sa Android — ML Kit o TensorFlow Lite. Isang PyTorch model ay kino-convert sa .mlpackage para sa Apple at sa .tflite para sa Android, na nagpapahintulot na mapanatili ang parehong kalidad ng ML functions sa parehong platforms. Ang approach na ito ay nangangailangan ng kaunting dagdag na effort sa DevOps, ngunit nagbibigay ng maximum na audience coverage.

Sa pagpili sa pagitan ng Core ML at mga alternatibo, isaalang-alang ang gastos ng development: ang Core ML ay nangangailangan ng mas kaunting code para sa integration (3–5 linya ng Swift kumpara sa 15–20 linya sa TFLite), ngunit nangangailangan ng Mac at Xcode para sa build. Ang ML Kit, sa kabaligtaran, ay gumagana sa anumang platform, ngunit nagbibigay ng mas mababang performance sa iOS dahil sa kakulangan ng access sa Apple Neural Engine.