Core ML — ce este, model de învățare automată și funcționare în iOS

Ce este Core ML?

Core ML — este un framework de învățare automată prezentat de Apple la WWDC 2017 ca parte a ecosistemului de dezvoltare pentru iPhone, iPad, Mac, Apple Watch și Apple TV. Core ML oferă un mediu de execuție pentru rularea modelelor ML pe dispozitiv, abstractizând dezvoltatorul de detaliile de optimizare hardware. Framework-ul selectează automat cel mai bun motor de calcul — Neural Engine pe cipurile A12+, GPU sau CPU — pentru fiecare operație a modelului.

Avantajul cheie al Core ML — integrarea profundă cu Apple Silicon. Operațiile rețelelor neuronale sunt executate pe Neural Engine dedicat, care nu încarcă nucleele principale ale procesorului. Potrivit Apple (WWDC 2025), modelele Core ML rulează de 6 ori mai rapid comparativ cu TensorFlow Lite pe dispozitive Android similare.

Capabilități principale

Core ML suportă o gamă largă de sarcini de învățare automată: clasificarea imaginilor, detectarea obiectelor, segmentarea semantică, procesarea limbajului natural, analiza sunetului și date tabelare. Framework-ul lucrează cu modele de diferite tipuri: rețele neuronale (convoluționale, recurente, transformere), ansambluri de arbori, regresii liniare și procese Gauss.

Cum funcționează Core ML

Core ML primește la intrare un model antrenat în format .mlpackage, îl compilează în cod mașină optimizat pentru dispozitivul specific și rulează inferența printr-un API unificat. Întregul pipeline — de la încărcarea modelului până la obținerea rezultatului — necesită 3–5 linii de cod în Swift.

Formatul modelului .mlpackage

.mlpackage — este un format container, introdus de Apple în 2020 pentru a înlocui .mlmodel învechit. Pachetul reprezintă un director cu manifest JSON, fișier model în format binar MLProgram, metadate (autor, versiune, descriere) și resurse, cum ar fi etichete de clase. Potrivit Apple, .mlpackage reduce dimensiunea modelului cu 30–50% comparativ cu .mlmodel datorită optimizării greutăților.

Apple Neural Engine

Apple Neural Engine (ANE) — un neuroprocesor dedicat integrat în cipurile Apple începând cu A12 Bionic (2018). ANE procesează operațiile matriceale de zeci de ori mai eficient decât CPU la același consum de energie. Performanța ANE a crescut de la 5 TOPS pe A12 la 35 TOPS pe M4 Ultra (2025), permițând rularea modelelor cu miliarde de parametri. ANE este utilizat automat pentru toate modelele Core ML cu arhitectură de rețea neuronală.

O caracteristică importantă a Core ML — suportul pentru cuantizare a modelelor la FP16 și INT8 fără pierdere de precizie. Cuantizarea reduce dimensiunea modelului de 2–4 ori și accelerează inferența cu 40–60% pe ANE. Apple oferă instrumentul Xcode Model Quantization pentru selectarea automată a preciziei optime: dezvoltatorul încarcă modelul, specifică pierderea de calitate admisibilă (de obicei 0.1–0.5%), iar Xcode selectează cel mai bun format de reprezentare a greutăților.

Compararea performanței Core ML

Conversia modelelor în Core ML

Majoritatea modelelor ML sunt create în PyTorch sau TensorFlow și necesită conversie în format .mlpackage pentru utilizare în Core ML. Apple oferă utilitarul coremltools — un pachet Python pentru conversia, optimizarea și validarea modelelor.

Instrumentul coremltools

coremltools — este utilitarul oficial Apple pentru conversia modelelor ML. Suportă importul din PyTorch (prin torch.onnx sau direct), TensorFlow (SavedModel, H5, Frozen Graph) și ONNX. După conversie se poate activa cuantizarea FP16 sau INT8, ceea ce reduce dimensiunea modelului de 2–4 ori fără pierdere semnificativă de precizie.

Exemplu de conversie din PyTorch

Să examinăm conversia unui model antrenat PyTorch în format Core ML folosind coremltools versiunea 8.0. Procesul necesită 2–3 pași în Python.

import torch
import coremltools as ct

# Încărcarea modelului PyTorch antrenat
model = torch.load('model.pth')
model.eval()

# Trasarea modelului cu o intrare exemplu
example_input = torch.randn(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

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

Codul încarcă modelul antrenat PyTorch, efectuează JIT-tracing cu o intrare exemplu și îl convertește în formatul mlprogram (formatul binar Core ML). .mlpackage obținut poate fi tras în Xcode și utilizat imediat în codul Swift.

Integrarea Core ML într-o aplicație iOS

După conversia modelului, integrarea acestuia într-o aplicație iOS în Swift se realizează în câteva linii. Xcode generează automat o clasă Swift pentru model pe baza metadatelor .mlpackage.

Exemplu de cod Swift

Să examinăm un exemplu de clasificare a imaginii folosind Core ML și framework-ul Vision. Vision transformă automat imaginea la dimensiunea și formatul de pixeli necesare.

import CoreML
import Vision

// Încărcarea modelului Core ML
guard let model = try? VNCoreMLModel(
    for: MobileNetV2.configuration.model
) else { return }

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

    // Ieșirea top-3 predicții
    for result in results.prefix(3) {
        print("\(result.identifier):
              \(result.confidence)")
    }
}

// Pornirea procesării imaginii
let handler = VNImageRequestHandler(
    url: imageURL
)
try? handler.perform([request])

Codul Swift încarcă modelul MobileNetV2 prin framework-ul Vision, creează o cerere de clasificare și procesează rezultatul — un tablou de obiecte VNClassificationObservation cu etichete de clase și încredere în procente. Întregul pipeline de la încărcare până la obținerea rezultatului durează 5–50 ms în funcție de model.

Pentru optimizarea timpului de pornire, Core ML compilează modelul la prima utilizare. Compilarea prealabilă (precompiled model) reduce pornirea la rece de la 2–3 secunde la 100–200 ms. Se recomandă efectuarea compilării modelului în faza de build în Xcode, nu la prima lansare a aplicației. Acest lucru este deosebit de important pentru aplicațiile cu mai multe modele ML — de exemplu, detectarea obiectelor + clasificare + NLP.

Core ML vs ML Kit

Core ML și ML Kit rezolvă sarcini similare de ML on-device, dar sunt orientate către ecosisteme diferite. Core ML este profund integrat cu Apple Silicon și suportă doar platformele Apple. ML Kit de la Google este o soluție cross-platformă pentru Android și iOS.

Alegeți Core ML dacă ecosistemul dumneavoastră este exclusiv Apple și aveți nevoie de performanță maximă prin ANE. Dacă este necesară cross-platforma sau API-uri gata făcute fără conversie — ML Kit va fi mai practic.

În practică, multe proiecte folosesc ambele framework-uri: pe iOS Core ML pentru performanță ridicată, iar pe Android — ML Kit sau TensorFlow Lite. Un singur model PyTorch este convertit în .mlpackage pentru Apple și în .tflite pentru Android, ceea ce permite menținerea aceleiași calități ML pe ambele platforme. Această abordare necesită puțin mai mult efort în DevOps, dar oferă acoperire maximă a audienței.

La alegerea între Core ML și alternative, luați în considerare costul de dezvoltare: Core ML necesită mai puțin cod pentru integrare (3–5 linii Swift față de 15–20 linii cu TFLite), dar necesită Mac și Xcode pentru build. ML Kit, dimpotrivă, funcționează pe orice platformă, dar oferă performanță mai mică pe iOS din cauza lipsei accesului la Apple Neural Engine.