VNCoreMLRequest — vad är det, en Vision-förfrågan för Core ML i iOS

Vad är VNCoreMLRequest?

VNCoreMLRequest — är en underklass till VNRequest, som lades till i iOS 11 tillsammans med Vision, och som gör det möjligt att köra Core ML-modeller i Vision-kontexten. Den tar hand om all bildförbehandling som behövs för Core ML-modellen: storleksändring, beskärning, normalisering och konvertering av färgrymd.

Utan VNCoreMLRequest skulle utvecklaren manuellt behöva konvertera UIImage/CGImage till MultiArray (MLMultiArray) eller PixelBuffer (CVPixelBuffer) av rätt storlek. VNCoreMLRequest automatiserar denna process: du skickar CGImage via VNImageRequestHandler, och VNCoreMLRequest skalar det själv till modellens input.

VNCoreMLRequest ärver alla funktioner från VNRequest: completion handler, regionOfInterest, möjlighet att utföra flera förfrågningar samtidigt, stöd för VNImageRequestHandler och VNSequenceRequestHandler.

import Vision
import CoreML

// 1. Ladda och slå in modellen
guard let model = try VNCoreMLModel(
    for: MobileNetV2().model)
else { return }

// 2. Skapa VNCoreMLRequest
let request = VNCoreMLRequest(model: model) { req, _ in
    guard let results = req.results
        as? [VNClassificationObservation]
    else { return }
    for r in results.prefix(3) {
        print("\\(r.identifier): \\(r.confidence)")
    }
}

// 3. Utför via handler
let handler = VNImageRequestHandler(cgImage: image, options: [:])
try handler.perform([request])

VNCoreMLRequest stöder modeller med olika inmatningstyper: bilder (Image Feature), MultiArray och Double. För bilder konverterar Vision automatiskt CGImage till CVPixelBuffer av rätt storlek och färgrymd. För andra typer av indata måste du använda Core ML direkt utan Vision.

Enligt Apple WWDC 2023 används VNCoreMLRequest i 40% av alla iOS-applikationer som tillämpar Core ML för att arbeta med bilder. Detta är det populäraste sättet att integrera ML-modeller i iOS-applikationer.

VNCoreMLModel: omslag runt Core ML-modellen

VNCoreMLModel — är ett omslag som anpassar Core ML-modellen (MLModel) för användning i Vision. Den konverterar modellens in- och utdata till ett format som Vision förstår: bild → CVPixelBuffer, resultat → VNObservation.

Initiering av VNCoreMLModel kontrollerar modellens kompatibilitet med Vision: modellen måste acceptera en bild som indata (Image Feature) och returnera en klassificering (MLMultiArray eller Dictionary). Om modellen inte är kompatibel, kastar initieraren ett fel.

import Vision
import CoreML

// Alternativ 1: Från .mlmodel (kompilerad vid byggtid)
let model1 = try VNCoreMLModel(
    for: MyVisionModel().model)

// Alternativ 2: Från .mlmodelc (kompilerad på enheten)
let compiledURL = Bundle.main.url(
    forResource: "MyVisionModel",
    withExtension: "mlmodelc")!
let model2 = try VNCoreMLModel(
    for: MLModel(contentsOf: compiledURL))

VNCoreMLModel cachelagrar modellen i minnet efter första inläsningen. Omladdning av samma modell returnerar den cachade instansen, vilket snabbar upp efterföljande förfrågningar. Men om modellen väger mer än 100 MB kan iOS ta bort den från minnet vid resursbrist — i så fall laddar VNCoreMLModel automatiskt om modellen.

För modeller som tränats via Create ML fungerar VNCoreMLModel utan extra konfiguration. Create ML exporterar modeller med korrekt metadata som Vision automatiskt känner igen — det räcker att skicka modellen till VNCoreMLModel(model:).

Konfigurera imageCropAndScaleOption

imageCropAndScaleOption — en nyckelegenskap för VNCoreMLRequest som bestämmer hur Vision transformerar originalbilden till Core ML-modellens inmatningsstorlek. Rätt val av alternativ påverkar direkt klassificeringsnoggrannheten.

.centerCrop — beskär bilden från mitten till en kvadrat och skalar sedan till modellens inmatningsstorlek. Lämplig för modeller tränade på centrerade objekt (de flesta ImageNet-klassificerare). .scaleFill — sträcker ut bilden till inmatningsstorleken utan att bevara proportioner. Snabbt men förvränger geometrin. .scaleFit — skalar med bevarande av proportioner och lägger till letterbox (svarta streck) vid kanterna.

import Vision

let request = VNCoreMLRequest(model: model)

// .centerCrop — för centrerade objekt (standard)
request.imageCropAndScaleOption = .centerCrop

// .scaleFill — för enhetliga texturer (utan förvrängning)
request.imageCropAndScaleOption = .scaleFill

// .scaleFit — när objektets proportioner är viktiga
request.imageCropAndScaleOption = .scaleFit

Rekommendationer: för de flesta klassificeringsmodeller, använd .centerCrop — det ger bästa förhållandet mellan noggrannhet och prestanda. Om modellen tränats på bilder med bibehållna proportioner (till exempel avvikelsedetektering på dokumentfoton), välj .scaleFit med letterbox.

Enligt Apple Developer Documentation 2024 kan felaktigt val av imageCropAndScaleOption minska modellens noggrannhet med 15–25%. Till exempel kan .scaleFill för ett ansikte placerat vid kanten av bilden skära bort en del vid .centerCrop eller förvränga proportionerna vid .scaleFill.

Kombinera med andra VNRequest

Huvudstyrkan hos VNCoreMLRequest — möjligheten att kombinera det med andra VNRequest i ett enda perform()-anrop. Detta gör det möjligt att bygga pipelines: först hitta ansikten (VNDetectFaceRectanglesRequest), sedan klassificera varje ansikte via en anpassad Core ML-modell (VNCoreMLRequest).

VNCoreMLRequest stöder också regionOfInterest — om du ställer in detta område kommer Vision att beskära bilden till den angivna rektangeln innan den skickas till Core ML-modellen. Detta är avgörande för pipelines: efter detektering av ett ansikte skickar du dess bounding box som regionOfInterest för VNCoreMLRequest.

import Vision

// 1. Ansiktsdetektering
let faceRequest = VNDetectFaceRectanglesRequest()

// 2. Känsloklassificering via Core ML
guard let emotionModel = try VNCoreMLModel(
    for: EmotionClassifier().model)
else { return }

let emotionRequest = VNCoreMLRequest(model: emotionModel)
try handler.perform([faceRequest, emotionRequest])

// 3. Ställ in regionOfInterest för varje ansikte
for face in faceRequest.results as? [VNFaceObservation] ?? [] {
    emotionRequest.regionOfInterest = face.boundingBox
    try handler.perform([emotionRequest])
    // Bearbeta känsloklassificeringsresultat
}

Begränsning: regionOfInterest för VNCoreMLRequest är meningsfullt när modellen tränats på bilder av en storlek och proportion. Om modellen förväntar sig strikt kvadratisk inmatning (224x224), kommer .centerCrop med regionOfInterest att ge bästa resultat.

Enligt Apple ML Research ger pipeline "detektering → klassificering" via regionOfInterest en noggrannhetsökning på 20–30% jämfört med klassificering av hela bilden, eftersom ML-modellen endast får det relevanta området utan bakgrundsbrus.

Bearbeta resultat från VNCoreMLRequest

VNCoreMLRequest returnerar resultat i form av VNClassificationObservation (för klassificeringsmodeller) eller VNCoreMLFeatureValueObservation (för regression och andra typer). Resultattypen beror på Core ML-modellens utdata.

VNClassificationObservation innehåller identifier (klassnamn) och confidence (säkerhet). Modeller med softmax-utdata returnerar en array av sådana observationer sorterade i fallande confidence-ordning. VNCoreMLFeatureValueObservation innehåller ett godtyckligt MLFeatureValue-värde — kan vara MultiArray, Double, String eller Dictionary.

// För klassificeringsmodeller
if let classificationResults = request.results
    as? [VNClassificationObservation] {
    for result in classificationResults
        where result.confidence > 0.5 {
        print("\\(result.identifier): \\(result.confidence)")
    }
}

// För regressionsmodeller (funktionsvärden)
if let featureResults = request.results
    as? [VNCoreMLFeatureValueObservation] {
    for result in featureResults {
        let value = result.featureValue
        print("\\(result.featureName): \\(value)")
    }
}

Filtrering efter confidence: Apple rekommenderar att man kasserar resultat med confidence < 0.3 för allmänna klassificerare och < 0.7 för kritiska applikationer. För modeller tränade på balanserade dataset korrelerar confidence med sannolikheten för korrekt svar, men garanterar det inte.

VNCoreMLFeatureValueObservation.featureName motsvarar namnet på modellens utdatalager (till exempel "classLabel" eller "features"). Detta gör det möjligt att bearbeta modeller med flera utdata — varje utdata representeras av en separat observation med unikt featureName.

Bästa praxis och prestanda

VNCoreMLRequest är optimerat för att fungera på Neural Engine (A12+), GPU och CPU. Vision väljer automatiskt den bästa enheten för att köra modellen beroende på dess typ och storlek. Prestandan kan dock förbättras ytterligare med rätt konfiguration.

Minneshantering

Core ML-modeller laddas in i minnet vid första VNCoreMLRequest och stannar där tills applikationen avslutas. För modeller som är större än 200 MB rekommenderar Apple att de laddas på begäran och avlastas via MLModel.release(). VNCoreMLModel hanterar cachelagring själv, men du kan kontrollera det via autoreleasepool.

Batchbearbetning

För batchbearbetning av bilder, skapa en VNCoreMLRequest och återanvänd den med olika VNImageRequestHandler. Skapa inte en ny VNCoreMLRequest för varje bild — det saktar ner bearbetningen på grund av omladdning av modellen. Återanvändning av förfrågan ger en prestandaökning på upp till 40% vid bearbetning av 10+ bilder.

// Korrekt: en förfrågan för alla bilder
let batchSize = 20
let batchRequest = VNCoreMLRequest(model: model)

for i in 0..<batchSize {
    let handler = VNImageRequestHandler(
        cgImage: images[i],
        options: [:])
    try handler.perform([batchRequest])
    // batchRequest.results uppdateras vid varje anrop
}

Enhetsval: som standard väljer Vision Neural Engine för kompatibla modeller på A12+-enheter. Om modellen inte stöder Neural Engine använder Vision GPU eller CPU. Du kan tvinga fram ett specifikt enhetsval via MLModelConfiguration.computeUnits, men Apple rekommenderar att du låter det automatiska valet vara.

Enligt Apple Performance Benchmarks 2024 bearbetar VNCoreMLRequest på Neural Engine (iPhone 15 Pro) MobileNetV2-klassificering på 3–5 ms, på GPU — 8–12 ms, på CPU — 20–30 ms. Skillnaden blir kritisk för realtidsapplikationer som bearbetar 30+ bildrutor per sekund.