Core ML — mi ez, gépi tanulási modell és működés iOS-ben

Mi az a Core ML?

Core ML — egy gépi tanulási keretrendszer, amelyet az Apple a WWDC 2017-en mutatott be az iPhone, iPad, Mac, Apple Watch és Apple TV fejlesztési ökoszisztéma részeként. A Core ML futásidejű környezetet biztosít ML modellek eszközön történő futtatásához, elvonatkoztatva a fejlesztőt a hardveroptimalizálás részleteitől. A keretrendszer automatikusan kiválasztja a legjobb számítási motort — Neural Engine-t A12+ chipeken, GPU-t vagy CPU-t — minden modellművelethez.

A Core ML kulcsfontosságú előnye — mély integráció az Apple Siliconnal. A neurális hálózati műveletek a dedikált Neural Engine-en futnak, amely nem terheli a processzor fő magjait. Az Apple (WWDC 2025) szerint a Core ML modellek 6-szor gyorsabban működnek, mint a TensorFlow Lite hasonló Android eszközökön.

Fő képességek

Core ML a gépi tanulási feladatok széles skáláját támogatja: képosztályozás, objektumdetektálás, szemantikus szegmentálás, természetes nyelvfeldolgozás, hanganalízis és táblázatos adatok. A keretrendszer különböző típusú modellekkel dolgozik: neurális hálózatok (konvolúciós, rekurrens, transzformerek), faegyüttesek, lineáris regressziók és Gauss-folyamatok.

Hogyan működik a Core ML

Core ML bemenetként egy betanított modellt fogad .mlpackage formátumban, optimalizált gépi kódra fordítja az adott eszközhöz, és elindítja a következtetést egy egységes API-n keresztül. A teljes folyamat — a modell betöltésétől az eredmény eléréséig — 3–5 sornyi Swift kódot igényel.

.mlpackage modellformátum

.mlpackage — egy tárolóformátum, amelyet az Apple 2020-ban vezetett be az elavult .mlmodel helyettesítésére. A csomag egy könyvtár JSON manifesttel, MLProgram bináris formátumú modellfájllal, metaadatokkal (szerző, verzió, leírás) és erőforrásokkal, mint például osztálycímkék. Az Apple szerint a .mlpackage 30–50%-kal csökkenti a modell méretét a .mlmodel-hez képest a súlyok optimalizálásának köszönhetően.

Apple Neural Engine

Apple Neural Engine (ANE) — dedikált neuroprocesszor, amely az A12 Bionic (2018) óta az Apple chipekbe van építve. Az ANE mátrixműveleteket tízszer hatékonyabban dolgoz fel, mint a CPU azonos energiafogyasztás mellett. Az ANE teljesítménye 5 TOPS-ról (A12) 35 TOPS-ra (M4 Ultra, 2025) nőtt, lehetővé téve milliárd paraméterrel rendelkező modellek futtatását. Az ANE automatikusan használatos minden neurális hálózati architektúrájú Core ML modellhez.

A Core ML fontos jellemzője — a modellek kvantálásának támogatása FP16 és INT8 formátumra pontosságvesztés nélkül. A kvantálás 2–4-szeresére csökkenti a modell méretét és 40–60%-kal gyorsítja a következtetést az ANE-n. Az Apple Xcode Model Quantization eszközt biztosít az optimális pontosság automatikus kiválasztásához: a fejlesztő betölti a modellt, megadja a megengedett minőségromlást (általában 0.1–0.5%), és az Xcode kiválasztja a súlyok legjobb reprezentációs formátumát.

Core ML teljesítmény összehasonlítás

Modellek konvertálása Core ML formátumba

A legtöbb ML modellt PyTorch vagy TensorFlow keretrendszerben hozzák létre, és konvertálni kell .mlpackage formátumba a Core ML-ben való használathoz. Az Apple a coremltools eszközt biztosítja — egy Python csomagot modellek konvertálásához, optimalizálásához és érvényesítéséhez.

A coremltools eszköz

coremltools — az Apple hivatalos eszköze ML modellek konvertálásához. Támogatja az importálást PyTorch-ból (torch.onnx-en keresztül vagy közvetlenül), TensorFlow-ból (SavedModel, H5, Frozen Graph) és ONNX-ből. A konvertálás után FP16 vagy INT8 kvantálás aktiválható, ami 2–4-szeresére csökkenti a modell méretét jelentős pontosságvesztés nélkül.

Példa PyTorch konverzióra

Vizsgáljuk meg egy betanított PyTorch modell Core ML formátumba konvertálását a coremltools 8.0 verziójával. A folyamat 2–3 lépést igényel Pythonban.

import torch
import coremltools as ct

# Betanított PyTorch modell betöltése
model = torch.load('model.pth')
model.eval()

# Modell követése mintabemenettel
example_input = torch.randn(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

# Konvertálás Core ML .mlpackage formátumba
mlmodel = ct.convert(
    traced_model,
    convert_to='mlprogram',
    inputs=[ct.TensorType(shape=(1, 3, 224, 224))]
)
mlmodel.save('Model.mlpackage')

A kód betölti a betanított PyTorch modellt, JIT-követést végez egy mintabemenettel, és mlprogram formátumba (Core ML bináris formátum) konvertálja. A kapott .mlpackage áthúzható az Xcode-ba és azonnal használható Swift kódban.

Core ML integrálása iOS alkalmazásba

A modell konvertálása után annak integrálása egy iOS alkalmazásba Swift-ben néhány sorban történik. Az Xcode automatikusan létrehoz egy Swift osztályt a modellhez a .mlpackage metaadatok alapján.

Példa Swift kódra

Vizsgáljunk meg egy képosztályozási példát Core ML és a Vision keretrendszer használatával. A Vision automatikusan átalakítja a képet a kívánt méretre és pixelformátumra.

import CoreML
import Vision

// Core ML modell betöltése
guard let model = try? VNCoreMLModel(
    for: MobileNetV2.configuration.model
) else { return }

// VNCoreMLRequest létrehozása
let request = VNCoreMLRequest(model: model) { request, error in
    guard let results = request.results
        as? [VNClassificationObservation]
    else { return }

    // Top-3 előrejelzés kiírása
    for result in results.prefix(3) {
        print("\(result.identifier):
              \(result.confidence)")
    }
}

// Képfeldolgozás elindítása
let handler = VNImageRequestHandler(
    url: imageURL
)
try? handler.perform([request])

A Swift kód betölti a MobileNetV2 modellt a Vision keretrendszeren keresztül, létrehoz egy osztályozási kérést, és feldolgozza az eredményt — VNClassificationObservation objektumok tömbjét osztálycímkékkel és százalékos biztonsággal. A teljes folyamat a betöltéstől az eredményig 5–50 ms-ot vesz igénybe a modelltől függően.

Az indítási idő optimalizálásához a Core ML az első használatkor fordítja le a modellt. Az előzetes fordítás (precompiled model) a hidegindítást 2–3 másodpercről 100–200 ms-ra csökkenti. Javasolt a modell fordítását az Xcode-ban a build fázisban elvégezni, nem az alkalmazás első indításakor. Ez különösen fontos több ML modellel rendelkező alkalmazásoknál — például objektumdetektálás + osztályozás + NLP.

Core ML vs ML Kit

Core ML és az ML Kit hasonló on-device ML feladatokat oldanak meg, de különböző ökoszisztémákra irányulnak. A Core ML mélyen integrált az Apple Siliconnal és csak Apple platformokat támogat. A Google ML Kit egy cross-platform megoldás Androidra és iOS-re.

Válassza a Core ML-t, ha ökoszisztémája kizárólag Apple, és maximális teljesítményre van szüksége az ANE-n keresztül. Ha cross-platform vagy kész API-k szükségesek konverzió nélkül — az ML Kit gyakorlatiasabb lesz.

A gyakorlatban sok projekt mindkét keretrendszert használja: iOS-en Core ML a nagy teljesítményhez, Androidon pedig ML Kit vagy TensorFlow Lite. Egyetlen PyTorch modellt .mlpackage formátumba konvertálnak Apple-hez és .tflite formátumba Androidhoz, ami lehetővé teszi azonos ML minőség fenntartását mindkét platformon. Ez a megközelítés egy kicsit több erőfeszítést igényel DevOps-ban, de maximális közönséglefedettséget biztosít.

A Core ML és alternatívák közötti választáskor vegye figyelembe a fejlesztési költségeket: a Core ML kevesebb kódot igényel az integrációhoz (3–5 sor Swift a TFLite 15–20 sorával szemben), de Mac-et és Xcode-ot igényel a buildhez. Az ML Kit ezzel szemben bármely platformon működik, de alacsonyabb teljesítményt nyújt iOS-en az Apple Neural Engine-hez való hozzáférés hiánya miatt.