Core ML: ce este, arhitectura framework-ului și integrarea modelelor

Ce este Core ML?

Core ML — este o componentă cheie a ecosistemului de învățare automată Apple, prezentată la WWDC 2017. Înainte de Core ML, dezvoltatorii iOS foloseau biblioteci terțe (TensorFlow Mobile, Caffe2) sau soluții proprii pentru a rula modele ML pe dispozitiv. Core ML a oferit o interfață unificată pentru toate tipurile de modele — de la regresii clasice la rețele neuronale profunde — și a preluat optimizarea de nivel scăzut pentru dispozitivul specific.

Istoricul dezvoltării

Prima versiune Core ML (2017) suporta doar modele statice cu dimensiune fixă a datelor de intrare. Core ML 2 (2018) a adăugat suport pentru batch prediction și actualizarea modelelor „din zbor”. Core ML 3 (2019) a adus învățarea pe dispozitiv și suport pentru zeci de noi straturi de rețele neuronale. Core ML 4 (2021) a introdus suport pentru modele cu mai multe ieșiri și procesare îmbunătățită a imaginilor. Core ML 5 (2024) a adăugat suport pentru rețele neuronale dinamice și învățare supravegheată pe dispozitiv folosind noi straturi ML.

ML pe dispozitiv: avantaje

Executarea învățării automate pe dispozitiv oferă trei avantaje cheie: confidențialitate — datele nu părăsesc dispozitivul (îndeplinește cerințele GDPR și HIPAA), viteză — inferența se execută în milisecunde fără întârzierea transmiterii datelor prin rețea, disponibilitate offline — modelul funcționează fără conexiune la internet. Potrivit Apple Privacy Report (2025), peste 90% din inferențele ML pe platformele Apple sunt executate pe dispozitiv datorită Core ML.

Arhitectura Core ML și calculatoarele

Arhitectura Core ML este construită pe principiul multistrat: la nivelul superior — API pentru dezvoltator (MLModel, MLFeatureProvider, MLPredictionOptions), la nivelul mijlociu — modelul în format .mlpackage, la nivelul inferior — calculatoarele: Apple Neural Engine (ANE), GPU (Metal Shaders) și CPU (BNNS, Accelerate framework). Core ML selectează automat cel mai bun calculator în funcție de model și hardware-ul dispozitivului.

Apple Neural Engine

Neural Engine (ANE) — este un neuroprocesor specializat încorporat în cipurile Apple A12+ și M1+. ANE este optimizat pentru executarea operațiilor rețelelor neuronale convoluționale (CNN) și a multiplicatorilor de matrice cu o performanță de până la 15.8 TOPS pe A17 Pro și 38 TOPS pe M4. Core ML detectează automat dacă modelul poate fi executat pe ANE și, dacă da, îl încarcă acolo. Dacă modelul conține operații nesuportate de ANE, Core ML distribuie calculele între GPU și CPU.

Metal Performance Shaders

Pentru calcule pe GPU, Core ML folosește Metal Performance Shaders Graph (MPSGraph), un framework pentru construirea și executarea grafelor de calcul pe GPU. MPSGraph preia graful rețelei neuronale din Core ML și îl compilează în Metal Shaders, optimizate pentru arhitectura GPU specifică (GPU A17 cu 7 nuclee sau GPU M4 Ultra cu 40 de nuclee). Optimizările automate MPSGraph includ îmbinarea straturilor, eliminarea operațiilor redundante și selectarea formatului optim de date.

Tipuri de modele și formate suportate

Core ML suportă toate tipurile principale de modele de învățare automată, împărțite în trei categorii: rețele neuronale (CNN convoluționale, RNN/LSTM recurente, transformere), modele ensemble (Random Forest, Gradient Boosting, XGBoost, Decision Trees) și modele de regresie (regresie liniară, SVM, CRF). Fiecare tip de model are propriul subprotocol MLModelType, iar Core ML selectează automat calculatorul și formatul de execuție corespunzător.

Straturi de rețele neuronale suportate

Core ML suportă peste 150 de tipuri de straturi de rețele neuronale: Convolution (1D/2D/3D), BatchNormalization, Pooling (Max/Average), Activation (ReLU, Sigmoid, Tanh, LeakyReLU, PReLU), Recurrent (LSTM/GRU/SimpleRNN), Transformers (MultiHeadAttention, LayerNorm), straturi specifice Metal. Pentru straturile nesuportate, Core ML oferă mecanismul custom layer — posibilitatea de a scrie implementarea stratului în Metal Shading Language sau Swift.

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

Formate de fișiere model

Până în 2021, Core ML folosea formatul .mlmodel — un fişier binar care conținea toate greutățile și metadatele modelului. Începând cu Xcode 13 și Core ML 4, Apple a introdus noul format .mlpackage — o structură de pachet bazată pe director care conține modelul, metadatele, descrierea intrărilor/ieșirilor și fișierele de pre- și post-procesare în format JSON. mlpackage suportă versionarea git, ceea ce simplifică munca în echipă. Conversia .mlmodel în .mlpackage se face cu Xcode Model Compiler sau cu scriptul coremltools în Python.

Conversia modelelor în Core ML

Conversia modelelor din framework-uri terțe în Core ML se realizează cu ajutorul bibliotecii coremltools în Python. coremltools suportă importul modelelor din TensorFlow 1.x/2.x (SavedModel, PB, HDF5), PyTorch (TorchScript, modele traced/scripted), Keras (H5), ONNX și create cu Create ML. Conducta standard de conversie include trei pași: încărcarea modelului în formatul original, conversia în MIL (Model Intermediate Language) — reprezentarea internă Core ML, și exportul în .mlpackage.

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")

Verificarea modelului după conversie

După conversie, trebuie verificată acuratețea modelului, comparând predicțiile modelului original și ale modelului Core ML convertit pe aceleași date. Diferența admisibilă — cel mult 1e-3 (0.1%) pentru Float32 și 1e-2 (1%) pentru Float16/Int8. coremltools oferă utilitarul ct.utils.compare_models() pentru comparare automată. Dacă diferența depășește norma, problema poate fi în operațiile nesuportate — acestea trebuie înlocuite cu custom layers sau modelul simplificat.

Optimizarea performanței Core ML

Optimizarea modelului Core ML este procesul de reducere a dimensiunii modelului și creștere a vitezei de inferență fără pierdere semnificativă de acuratețe. Apple oferă mai multe instrumente de optimizare integrate în coremltools și Xcode: cuantizare (reducerea preciziei greutăților), tăierea conexiunilor (îndepărtarea neuronilor nesemnificativi), îndepărtarea straturilor redundante și îmbinarea straturilor (fusion) pentru reducerea grafului de calcul.

Cuantizarea la Float16 și Int8

Cuantizarea reduce dimensiunea modelului de aproximativ 2 ori (Float16) sau 4 ori (Int8) în comparație cu Float32. Core ML suportă trei moduri de cuantizare: cuantizare post-antrenament (PTQ) cu un set de date de calibrare, în timpul conversiei prin coremltools și antrenament cu conștientizarea cuantizării (QAT). Pentru majoritatea modelelor de viziune computerizată, PTQ la Float16 oferă o pierdere de acuratețe sub 0.5% cu dublarea vitezei de inferență.

Profilarea modelului în Xcode

Xcode oferă instrumentul Core ML Model Profiler, care permite măsurarea performanței modelului pe diverse dispozitive în simulator sau pe un dispozitiv real. Profilerul arată timpul de execuție al fiecărui strat, încărcarea calculatorului (ANE/GPU/CPU), consumul maxim de memorie și blocajele modelului. Potrivit Apple Performance Optimization Guide, peste 80% dintre modele au cel puțin un strat care funcționează semnificativ mai lent decât celelalte (anomalie de strat), care poate fi optimizat prin înlocuire sau îmbinare.

Exemplu practic de integrare Core ML

Să analizăm integrarea unui model Core ML antrenat într-o aplicație iOS în Swift. După adăugarea fișierului .mlpackage în proiectul Xcode (prin tragere sau prin Swift Package Manager), Xcode generează automat clasa modelului în Swift, incluzând intrări și ieșiri tipizate. Dezvoltatorul nu trebuie să analizeze manual datele de intrare — clasa generată acceptă UIImage, MLMultiArray, String sau alte tipuri în funcţie de metadatele modelului.

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])

Tratarea erorilor și fallback

La integrarea Core ML trebuie prevăzută tratarea erorilor: modelul poate să nu se încarce din cauza incompatibilității cu dispozitivul (versiune iOS prea veche), insuficienței de memorie sau deteriorării fișierului modelului. Se recomandă implementarea logicii de fallback: dacă modelul nu s-a încărcat în formatul cuantizat Int8, încărcați versiunea Float16, iar dacă nici aceasta nu se încarcă — Float32. Potrivit Apple Crash Analytics, peste 5% din căderile aplicațiilor ML sunt cauzate de încărcarea incorectă a modelului.

Core ML vs Create ML: care este diferența

Core ML și Create ML sunt două instrumente complementare ale ecosistemului Apple ML. Core ML se ocupă de executarea modelelor pe dispozitiv (inferență), în timp ce Create ML se ocupă de antrenarea modelelor (training). Modelele create în Create ML sunt exportate exact în formatul Core ML (.mlpackage) pentru integrarea ulterioară în aplicații. Dacă facem o analogie cu dezvoltarea web, Core ML este browserul (execuția), iar Create ML este IDE-ul pentru scrierea codului (antrenarea).