Core ML: mi ez, a keretrendszer architektúrája és modellek integrálása

Mi az a Core ML?

Core ML — az Apple gépi tanulási ökoszisztémájának kulcsfontosságú összetevője, amelyet a WWDC 2017-en mutattak be. A Core ML előtt az iOS fejlesztők harmadik féltől származó könyvtárakat (TensorFlow Mobile, Caffe2) vagy saját megoldásokat használtak ML modellek eszközön történő futtatására. A Core ML egységes interfészt biztosított minden modelltípushoz — a klasszikus regresszióktól a mély neurális hálózatokig — és átvette az alacsony szintű optimalizálást az adott eszközhöz.

Fejlődéstörténet

A Core ML első verziója (2017) csak statikus modelleket támogatott rögzített bemeneti mérettel. A Core ML 2 (2018) hozzáadta a batch prediction és a modellek „menet közbeni” frissítésének támogatását. A Core ML 3 (2019) elhozta az eszközön történő tanulást és tucatnyi új neurális hálózati réteg támogatását. A Core ML 4 (2021) bevezette a több kimenettel rendelkező modellek és a továbbfejlesztett képfeldolgozás támogatását. A Core ML 5 (2024) hozzáadta a dinamikus neurális hálózatok és az eszközön végzett felügyelt tanulás támogatását új ML rétegek segítségével.

On-Device ML: előnyök

A gépi tanulás eszközön történő végrehajtása három fő előnnyel jár: adatbiztonság — az adatok nem hagyják el az eszközt (megfelel a GDPR és HIPAA követelményeinek), sebesség — az inferencia ezredmásodpercek alatt történik, a hálózati adatátvitel késleltetése nélkül, offline elérhetőség — a modell internetkapcsolat nélkül is működik. Az Apple Privacy Report (2025) szerint az Apple platformokon végzett ML inferenciák több mint 90%-a a Core ML-nek köszönhetően az eszközön történik.

A Core ML architektúrája és számító egységei

A Core ML architektúrája többréteges elven épül fel: a legfelső szinten — API a fejlesztő számára (MLModel, MLFeatureProvider, MLPredictionOptions), a középső szinten — a modell .mlpackage formátumban, az alsó szinten — a számító egységek: Apple Neural Engine (ANE), GPU (Metal Shaders) és CPU (BNNS, Accelerate framework). A Core ML automatikusan kiválasztja a legjobb számító egységet a modell és az eszköz hardverének függvényében.

Apple Neural Engine

Neural Engine (ANE) — egy speciális neuroprocesszor, amely az Apple A12+ és M1+ chipekbe van beágyazva. Az ANE a konvolúciós neurális hálózati műveletek (CNN) és mátrixszorzások végrehajtására van optimalizálva, akár 15.8 TOPS teljesítménnyel az A17 Pro-n és 38 TOPS-szal az M4-en. A Core ML automatikusan érzékeli, hogy a modell futtatható-e az ANE-n, és ha igen, betölti oda. Ha a modell olyan műveleteket tartalmaz, amelyeket az ANE nem támogat, a Core ML elosztja a számításokat a GPU és a CPU között.

Metal Performance Shaders

A GPU-n végzett számításokhoz a Core ML a Metal Performance Shaders Graph-ot (MPSGraph) használja, amely egy keretrendszer számítási gráfok GPU-n történő építésére és végrehajtására. Az MPSGraph elveszi a neurális hálózati gráfot a Core ML-től, és Metal Shaders-re fordítja, amelyek az adott GPU architektúrához (7 magos A17 GPU vagy 40 magos M4 Ultra GPU) vannak optimalizálva. Az MPSGraph automatikus optimalizálásai magukban foglalják a rétegek összevonását, a felesleges műveletek kiiktatását és az optimális adatformátum kiválasztását.

Támogatott modelltípusok és formátumok

A Core ML támogatja az összes főbb gépi tanulási modelltópust, három kategóriára osztva: neurális hálózatok (konvolúciós CNN, rekurrens RNN/LSTM, transzformerek), ensemble modellek (Random Forest, Gradient Boosting, XGBoost, Decision Trees) és regressziós modellek (lineáris regresszió, SVM, CRF). Minden modelltípusnak saját MLModelType alprotokollja van, és a Core ML automatikusan kiválasztja a megfelelő számító egységet és végrehajtási formátumot.

Támogatott neurális hálózati rétegek

A Core ML támogat több mint 150 típusú neurális hálózati réteget: Convolution (1D/2D/3D), BatchNormalization, Pooling (Max/Average), Activation (ReLU, Sigmoid, Tanh, LeakyReLU, PReLU), Recurrent (LSTM/GRU/SimpleRNN), Transformers (MultiHeadAttention, LayerNorm), Metal-specifikus rétegek. A nem támogatott rétegekhez a Core ML custom layer mechanizmust biztosít — lehetőséget a réteg implementációjának megírására Metal Shading Language-ben vagy Swift-ben.

let model = try MLModel(contentsOf: modelURL)
let input = try MLMultiArray(shape: [1, 224, 224, 3], dataType: .float32)
let prediction = try model.prediction(from: input)

Modellfájl formátumok

2021-ig a Core ML a .mlmodel formátumot használta — egy bináris fájlt, amely tartalmazta a modell összes súlyát és metaadatait. Az Xcode 13 és a Core ML 4 kezdetével az Apple bevezette az új .mlpackage formátumot — egy könyvtáralapú csomagszerkezetet, amely tartalmazza a modellt, metaadatokat, a bemenetek/kimenetek leírását és az elő- és utófeldolgozó fájlokat JSON formátumban. Az mlpackage támogatja a git verziókezelést, ami megkönnyíti a csapatmunkát. A .mlmodel .mlpackage-vé alakítását az Xcode Model Compiler vagy a coremltools szkript végzi Pythonban.

Modellek konvertálása Core ML-be

A modellek konvertálása harmadik fél keretrendszereiből Core ML-be a coremltools könyvtár segítségével történik Pythonban. A coremltools támogatja modellek importálását TensorFlow 1.x/2.x (SavedModel, PB, HDF5), PyTorch (TorchScript, traced/scripted modellek), Keras (H5), ONNX és Create ML segítségével létrehozott modellekből. A szabványos konvertálási csővezeték három lépésből áll: a modell betöltése az eredeti formátumban, konvertálás MIL-be (Model Intermediate Language) — a Core ML belső reprezentációjába, és exportálás .mlpackage formátumba.

import coremltools as ct

model = ct.converters.pytorch.convert(
    source = "model.pt",
    inputs = [ct.TensorType(shape=(1, 3, 224, 224))]
)
model.author = "IT Sectr"
model.short_description = "Image classifier"
model.save("MyModel.mlpackage")

A modell ellenőrzése konvertálás után

Konvertálás után ellenőrizni kell a modell pontosságát az eredeti modell és a konvertált Core ML modell előrejelzéseinek összehasonlításával ugyanazon az adatokon. Megengedett eltérés — legfeljebb 1e-3 (0,1%) Float32 esetén és 1e-2 (1%) Float16/Int8 esetén. A coremltools biztosítja a ct.utils.compare_models() segédprogramot az automatikus összehasonlításhoz. Ha az eltérés meghaladja a normát, a probléma a nem támogatott műveletekben lehet — ezeket custom layers-re kell cserélni vagy a modellt le kell egyszerűsíteni.

Core ML teljesítményoptimalizálás

A Core ML modell optimalizálása a modell méretének csökkentésének és az inferencia sebességének növelésének folyamata a pontosság jelentős elvesztése nélkül. Az Apple számos optimalizáló eszközt kínál, amelyek a coremltools-ba és az Xcode-ba vannak építve: kvantálás (a súlyok pontosságának csökkentése), ritkítás (jelentéktelen neuronok eltávolítása), redundáns rétegek eltávolítása és rétegösszevonás (fusion) a számítási gráf csökkentésére.

Kvantálás Float16 és Int8 formátumba

A kvantálás a modell méretét körülbelül 2-szeresére (Float16) vagy 4-szeresére (Int8) csökkenti a Float32-hez képest. A Core ML három kvantálási módot támogat: betanítás utáni kvantálás (PTQ) kalibrációs adathalmazzal, konvertálás közben a coremltools segítségével, és kvantálástudatos betanítás (QAT). A legtöbb számítógépes látási modell esetében a Float16-ra történő PTQ kevesebb mint 0,5%-os pontosságcsökkenést eredményez az inferencia sebességének megkétszerezése mellett.

Modellprofilozás az Xcode-ban

Az Xcode biztosítja a Core ML Model Profiler eszközt, amely lehetővé teszi a modell teljesítményének mérését különböző eszközökön a szimulátorban vagy egy valós eszközön. A profiler megmutatja az egyes rétegek végrehajtási idejét, a számító egység terhelését (ANE/GPU/CPU), a csúcs memóriafogyasztást és a modell szűk keresztmetszeteit. Az Apple Performance Optimization Guide szerint a modellek több mint 80%-a rendelkezik legalább egy olyan réteggel, amely jelentősen lassabban működik, mint a többiek (réteganomália), és ez optimalizálható cserével vagy összevonással.

Gyakorlati példa a Core ML integrálására

Nézzük meg egy betanított Core ML modell integrálását egy iOS alkalmazásba Swift-ben. Miután hozzáadta a .mlpackage fájlt az Xcode projekthez (húzással vagy a Swift Package Manager segítségével), az Xcode automatikusan legenerálja a modell osztályt Swift-ben, beleértve a típusos bemeneteket és kimeneteket. A fejlesztőnek nem kell kézzel elemeznie a bemeneti adatokat — a generált osztály UIImage, MLMultiArray, String vagy más típusokat fogad el a modell metaadataitól függően.

import CoreML
import Vision

guard let model = try? VNCoreMLModel(
    for: MyImageClassifier().model
) else { return }

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

    if let topResult = results.first {
        print("Class: \(topResult.identifier)")
        print("Confidence: \(topResult.confidence)")
    }
}

let handler = VNImageRequestHandler(
    cgImage: image.cgImage!,
    options: [:]
)
try handler.perform([request])

Hibakezelés és fallback

A Core ML integrálásakor gondoskodni kell a hibakezelésről: a modell előfordulhat, hogy nem töltődik be az eszközzel való inkompatibilitás (túl régi iOS verzió), memóriahiány vagy a modellfájl sérülése miatt. Javasolt fallback logika implementálása: ha a modell nem töltődik be kvantált Int8 formátumban, töltse be a Float16 verziót, és ha az sem töltődik be — Float32. Az Apple Crash Analytics szerint az ML alkalmazások összeomlásának több mint 5%-a a modell helytelen betöltéséből származik.

Core ML vs Create ML: mi a különbség

A Core ML és a Create ML az Apple ML ökoszisztéma két egymást kiegészítő eszköze. A Core ML a modellek eszközön történő végrehajtásáért (inferencia) felelős, míg a Create ML a modellek betanításáért (tréning). A Create ML-ben létrehozott modellek pontosan Core ML formátumba (.mlpackage) exportálódnak a későbbi alkalmazásokba történő integrációhoz. Ha analógiát vonunk a webfejlesztéssel, a Core ML a böngésző (végrehajtás), a Create ML pedig a kódíráshoz használt IDE (tanítás).