Core ML — vad är det, maskininlärningsmodell och arbete i iOS

Vad är Core ML?

Core ML — är ett maskininlärningsramverk som introducerades av Apple på WWDC 2017 som en del av utvecklingsekosystemet för iPhone, iPad, Mac, Apple Watch och Apple TV. Core ML tillhandahåller en körningsmiljö för att köra ML-modeller på enheten och abstraherar utvecklaren från detaljerna kring hårdvaruoptimering. Ramverket väljer automatiskt den bästa beräkningsmotorn — Neural Engine på A12+-chips, GPU eller CPU — för varje modelloperation.

Den viktigaste fördelen med Core ML — djup integration med Apple Silicon. Neurala nätverksoperationer utförs på den dedikerade Neural Engine, som inte belastar processorns huvudkärnor. Enligt Apple (WWDC 2025) fungerar Core ML-modeller 6 gånger snabbare jämfört med TensorFlow Lite på liknande Android-enheter.

Huvudfunktioner

Core ML stöder ett brett spektrum av maskininlärningsuppgifter: bildklassificering, objektdetektering, semantisk segmentering, naturlig språkbehandling, ljudanalys och tabelldata. Ramverket arbetar med modeller av olika typer: neurala nätverk (konvolutionella, rekursiva, transformatorer), trädsammansättningar, linjära regressioner och Gauss-processer.

Hur Core ML fungerar

Core ML tar emot en tränad modell i .mlpackage-format som indata, kompilerar den till optimerad maskinkod för den specifika enheten och startar inferens via ett enhetligt API. Hela pipelinen — från att ladda modellen till att få resultatet — kräver 3–5 rader kod i Swift.

Modellformat .mlpackage

.mlpackage — är ett containerformat som introducerades av Apple 2020 för att ersätta den föråldrade .mlmodel. Paketet är en katalog med JSON-manifest, modellfil i binärt MLProgram-format, metadata (författare, version, beskrivning) och resurser som klasetiketter. Enligt Apple minskar .mlpackage modellstorleken med 30–50% jämfört med .mlmodel tack vare optimering av vikter.

Apple Neural Engine

Apple Neural Engine (ANE) — en dedikerad neuroprocessor inbyggd i Apple-chips från och med A12 Bionic (2018). ANE behandlar matrisoperationer tiotals gånger effektivare än CPU med samma energiförbrukning. ANE-prestandan har ökat från 5 TOPS på A12 till 35 TOPS på M4 Ultra (2025), vilket möjliggör körning av modeller med miljarder parametrar. ANE används automatiskt för alla Core ML-modeller med neural nätverksarkitektur.

En viktig funktion i Core ML — stöd för kvantisering av modeller till FP16 och INT8 utan förlust av noggrannhet. Kvantisering minskar modellstorleken 2–4 gånger och snabbar upp inferens med 40–60% på ANE. Apple tillhandahåller verktyget Xcode Model Quantization för automatiskt val av optimal precision: utvecklaren laddar modellen, anger tillåten kvalitetsförlust (vanligtvis 0.1–0.5%), och Xcode väljer det bästa formatet för viktrepresentation.

Jämförelse av Core ML-prestanda

Konvertera modeller till Core ML

De flesta ML-modeller skapas i PyTorch eller TensorFlow och kräver konvertering till .mlpackage-format för användning i Core ML. Apple tillhandahåller verktyget coremltools — ett Python-paket för konvertering, optimering och validering av modeller.

Verktyget coremltools

coremltools — är Apples officiella verktyg för konvertering av ML-modeller. Det stöder import från PyTorch (via torch.onnx eller direkt), TensorFlow (SavedModel, H5, Frozen Graph) och ONNX. Efter konvertering kan FP16- eller INT8-kvantisering aktiveras, vilket minskar modellstorleken 2–4 gånger utan betydande förlust av noggrannhet.

Exempel på konvertering från PyTorch

Låt oss titta på konvertering av en tränad PyTorch-modell till Core ML-format med coremltools version 8.0. Processen kräver 2–3 steg i Python.

import torch
import coremltools as ct

# Ladda tränad PyTorch-modell
model = torch.load('model.pth')
model.eval()

# Spåra modell med exempelingång
example_input = torch.randn(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

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

Koden laddar den tränade PyTorch-modellen, utför JIT-spårning med en exempelingång och konverterar den till mlprogram-format (binärt Core ML-format). Det resulterande .mlpackage kan dras till Xcode och omedelbart användas i Swift-kod.

Integrera Core ML i en iOS-app

Efter modellkonvertering sker integrationen i en iOS-app i Swift på några rader. Xcode genererar automatiskt en Swift-klass för modellen baserat på .mlpackage-metadata.

Exempel på Swift-kod

Låt oss titta på ett exempel på bildklassificering med Core ML och Vision-ramverket. Vision konverterar automatiskt bilden till önskad storlek och pixelformat.

import CoreML
import Vision

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

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

    // Skriva ut top-3 förutsägelser
    for result in results.prefix(3) {
        print("\(result.identifier):
              \(result.confidence)")
    }
}

// Starta bildbehandling
let handler = VNImageRequestHandler(
    url: imageURL
)
try? handler.perform([request])

Swift-koden laddar MobileNetV2-modellen via Vision-ramverket, skapar en klassificeringsbegäran och bearbetar resultatet — en array av VNClassificationObservation-objekt med klasetiketter och förtroende i procent. Hela pipelinen från laddning till resultat tar 5–50 ms beroende på modell.

För optimering av starttiden kompilerar Core ML modellen vid första användningen. Förkompilering (precompiled model) minskar kallstart från 2–3 sekunder till 100–200 ms. Det rekommenderas att utföra modellkompilering i byggfasen i Xcode, inte vid första app-start. Detta är särskilt viktigt för appar med flera ML-modeller — till exempel objektdetektering + klassificering + NLP.

Core ML vs ML Kit

Core ML och ML Kit löser liknande on-device ML-uppgifter men är inriktade på olika ekosystem. Core ML är djupt integrerat med Apple Silicon och stöder endast Apple-plattformar. ML Kit från Google är en cross-platform-lösning för Android och iOS.

Välj Core ML om ditt ekosystem uteslutande är Apple och du behöver maximal prestanda via ANE. Om cross-platform eller färdiga API:er utan konvertering behövs — är ML Kit mer praktiskt.

I praktiken använder många projekt båda ramverken: på iOS Core ML för hög prestanda, och på Android — ML Kit eller TensorFlow Lite. En enda PyTorch-modell konverteras till .mlpackage för Apple och till .tflite för Android, vilket gör det möjligt att upprätthålla samma ML-kvalitet på båda plattformarna. Detta tillvägagångssätt kräver lite mer ansträngning i DevOps men ger maximal målgruppstäckning.

När du väljer mellan Core ML och alternativ, överväg utvecklingskostnaden: Core ML kräver mindre kod för integration (3–5 rader Swift jämfört med 15–20 rader med TFLite), men kräver Mac och Xcode för bygge. ML Kit fungerar däremot på alla plattformar men ger lägre prestanda på iOS på grund av bristande tillgång till Apple Neural Engine.