VNCoreMLRequest — ano ito, Vision request para sa Core ML sa iOS

Ano ang VNCoreMLRequest?

VNCoreMLRequest — ay isang subclass ng VNRequest, idinagdag sa iOS 11 kasama ng Vision, na nagbibigay-daan sa pagpapatakbo ng mga Core ML model sa konteksto ng Vision. Inaako nito ang lahat ng preprocessing ng larawan na kinakailangan para sa Core ML model: pagbabago ng laki, pag-crop, normalisasyon, at conversion ng color space.

Kung wala ang VNCoreMLRequest, kakailanganin ng developer na manu-manong i-convert ang UIImage/CGImage sa MultiArray (MLMultiArray) o PixelBuffer (CVPixelBuffer) ng tamang laki. Awtomatiko ng VNCoreMLRequest ang prosesong ito: ipapasa mo ang CGImage sa pamamagitan ng VNImageRequestHandler, at ang VNCoreMLRequest mismo ang magsas-scale nito sa input ng model.

VNCoreMLRequest ay nagmamana ng lahat ng kakayahan ng VNRequest: completion handler, regionOfInterest, kakayahang magsagawa ng maraming request nang sabay-sabay, suporta para sa VNImageRequestHandler at VNSequenceRequestHandler.

import Vision
import CoreML

// 1. I-load at i-wrap ang model
guard let model = try VNCoreMLModel(
    for: MobileNetV2().model)
else { return }

// 2. Gumawa ng 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. Isagawa sa pamamagitan ng handler
let handler = VNImageRequestHandler(cgImage: image, options: [:])
try handler.perform([request])

VNCoreMLRequest ay sumusuporta sa mga model na may iba't ibang uri ng input: mga larawan (Image Feature), MultiArray at Double. Para sa mga larawan, awtomatikong kino-convert ng Vision ang CGImage sa CVPixelBuffer ng tamang laki at color space. Para sa iba pang uri ng input data, kailangan mong gamitin ang Core ML nang direkta nang walang Vision.

Ayon sa Apple WWDC 2023, ang VNCoreMLRequest ay ginagamit sa 40% ng lahat ng iOS application na gumagamit ng Core ML para sa pagtatrabaho sa mga larawan. Ito ang pinakasikat na paraan ng pagsasama ng mga ML model sa iOS application.

VNCoreMLModel: wrapper sa paligid ng Core ML model

VNCoreMLModel — ay isang wrapper na nag-aangkop ng Core ML model (MLModel) para sa paggamit sa Vision. Kino-convert nito ang input at output data ng model sa format na nauunawaan ng Vision: larawan → CVPixelBuffer, resulta → VNObservation.

Sinusuri ng initialization ng VNCoreMLModel ang compatibility ng model sa Vision: ang model ay dapat tumanggap ng larawan bilang input (Image Feature) at magbalik ng klasipikasyon (MLMultiArray o Dictionary). Kung hindi compatible ang model, ang initializer ay maglalabas ng error.

import Vision
import CoreML

// Opsyon 1: Mula sa .mlmodel (compile sa oras ng build)
let model1 = try VNCoreMLModel(
    for: MyVisionModel().model)

// Opsyon 2: Mula sa .mlmodelc (compile sa device)
let compiledURL = Bundle.main.url(
    forResource: "MyVisionModel",
    withExtension: "mlmodelc")!
let model2 = try VNCoreMLModel(
    for: MLModel(contentsOf: compiledURL))

VNCoreMLModel ay nag-cache ng model sa memory pagkatapos ng unang pag-load. Ang muling pag-load ng parehong model ay nagbabalik ng naka-cache na instance, na nagpapabilis sa mga susunod na request. Gayunpaman, kung ang model ay tumitimbang ng higit sa 100 MB, maaaring i-unload ito ng iOS mula sa memory kapag kulang ang resources — sa kasong ito, awtomatikong magre-reload ang VNCoreMLModel ng model.

Para sa mga model na sinanay sa pamamagitan ng Create ML, gumagana ang VNCoreMLModel nang walang karagdagang configuration. Ang Create ML ay nag-e-export ng mga model na may tamang metadata na awtomatikong kinikilala ng Vision — sapat na upang ipasa ang model sa VNCoreMLModel(model:).

Pag-configure ng imageCropAndScaleOption

imageCropAndScaleOption — pangunahing property ng VNCoreMLRequest na tumutukoy kung paano binabago ng Vision ang orihinal na larawan sa laki ng input ng Core ML model. Ang tamang pagpili ng opsyon ay direktang nakakaapekto sa accuracy ng klasipikasyon.

.centerCrop — pinuputol ang larawan mula sa gitna hanggang sa isang parisukat, pagkatapos ay ini-scale sa laki ng input ng model. Angkop para sa mga model na sinanay sa mga naka-center na bagay (karamihan sa mga ImageNet classifier). .scaleFill — ini-stretch ang larawan sa laki ng input nang hindi pinapanatili ang proporsyon. Mabilis, ngunit nadi-distort ang geometry. .scaleFit — nag-scale habang pinapanatili ang proporsyon, nagdaragdag ng letterbox (mga itim na guhit) sa mga gilid.

import Vision

let request = VNCoreMLRequest(model: model)

// .centerCrop — para sa mga naka-center na bagay (default)
request.imageCropAndScaleOption = .centerCrop

// .scaleFill — para sa mga uniform na texture (walang distortion)
request.imageCropAndScaleOption = .scaleFill

// .scaleFit — kapag mahalaga ang proporsyon ng bagay
request.imageCropAndScaleOption = .scaleFit

Mga Rekomendasyon: para sa karamihan ng mga model ng klasipikasyon gamitin ang .centerCrop — nagbibigay ito ng pinakamahusay na ratio ng accuracy at performance. Kung ang model ay sinanay sa mga larawan na may pinapanatili na proporsyon (halimbawa, pag-detect ng anomalya sa mga litrato ng dokumento), piliin ang .scaleFit na may letterbox.

Ayon sa Apple Developer Documentation 2024, ang maling pagpili ng imageCropAndScaleOption ay maaaring magpababa ng accuracy ng model ng 15–25%. Halimbawa, ang .scaleFill para sa isang mukha na matatagpuan sa gilid ng frame ay maaaring pumutol ng bahagi nito sa .centerCrop o i-distort ang proporsyon sa .scaleFill.

Pagsasama sa iba pang VNRequest

Pangunahing lakas ng VNCoreMLRequest — ang kakayahang pagsamahin ito sa iba pang VNRequest sa isang tawag na perform(). Ito ay nagbibigay-daan sa pagbuo ng mga pipeline: unang hanapin ang mga mukha (VNDetectFaceRectanglesRequest), pagkatapos ay i-classify ang bawat mukha sa pamamagitan ng custom na Core ML model (VNCoreMLRequest).

VNCoreMLRequest ay sumusuporta rin sa regionOfInterest — kung itatakda mo ang lugar na ito, puputulin ng Vision ang larawan hanggang sa tinukoy na parihaba bago ito ipasa sa Core ML model. Ito ay kritikal para sa mga pipeline: pagkatapos ng detection ng mukha, ipapasa mo ang bounding box nito bilang regionOfInterest para sa VNCoreMLRequest.

import Vision

// 1. Detection ng mukha
let faceRequest = VNDetectFaceRectanglesRequest()

// 2. Klasipikasyon ng emosyon sa pamamagitan ng Core ML
guard let emotionModel = try VNCoreMLModel(
    for: EmotionClassifier().model)
else { return }

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

// 3. Itakda ang regionOfInterest para sa bawat mukha
for face in faceRequest.results as? [VNFaceObservation] ?? [] {
    emotionRequest.regionOfInterest = face.boundingBox
    try handler.perform([emotionRequest])
    // Iproseso ang resulta ng klasipikasyon ng emosyon
}

Limitasyon: ang regionOfInterest para sa VNCoreMLRequest ay may katuturan kapag ang model ay sinanay sa mga larawan ng isang laki at proporsyon. Kung ang model ay inaasahan ang mahigpit na parisukat na input (224x224), ang .centerCrop na may regionOfInterest ay magbibigay ng pinakamahusay na resulta.

Ayon sa Apple ML Research, ang pipeline na 'detection → classification' sa pamamagitan ng regionOfInterest ay nagbibigay ng pagtaas ng accuracy na 20–30% kumpara sa klasipikasyon ng buong larawan, dahil ang ML model ay tumatanggap lamang ng may-katuturang lugar na walang background na ingay.

Pagproseso ng mga resulta ng VNCoreMLRequest

VNCoreMLRequest ay nagbabalik ng mga resulta sa anyo ng VNClassificationObservation (para sa mga model ng klasipikasyon) o VNCoreMLFeatureValueObservation (para sa regression at iba pang uri). Ang uri ng resulta ay depende sa output data ng Core ML model.

VNClassificationObservation ay naglalaman ng identifier (pangalan ng klase) at confidence (katiyakan). Ang mga model na may softmax output ay nagbabalik ng array ng mga naturang obserbasyon, na pinagsunod-sunod ayon sa pababang confidence. VNCoreMLFeatureValueObservation ay naglalaman ng arbitrary na halaga ng MLFeatureValue — maaaring MultiArray, Double, String o Dictionary.

// Para sa mga model ng klasipikasyon
if let classificationResults = request.results
    as? [VNClassificationObservation] {
    for result in classificationResults
        where result.confidence > 0.5 {
        print("\\(result.identifier): \\(result.confidence)")
    }
}

// Para sa mga model ng regression (mga halaga ng feature)
if let featureResults = request.results
    as? [VNCoreMLFeatureValueObservation] {
    for result in featureResults {
        let value = result.featureValue
        print("\\(result.featureName): \\(value)")
    }
}

Pagsasala ayon sa confidence: Inirerekomenda ng Apple na itapon ang mga resulta na may confidence < 0.3 para sa mga pangkalahatang classifier at < 0.7 para sa mga kritikal na application. Para sa mga model na sinanay sa balanseng dataset, ang confidence ay nakakaugnay sa posibilidad ng tamang sagot, ngunit hindi ito ginagarantiyahan.

VNCoreMLFeatureValueObservation.featureName ay tumutugma sa pangalan ng output layer ng model (halimbawa, 'classLabel' o 'features'). Ito ay nagbibigay-daan sa pagproseso ng mga model na may maraming output — bawat output ay kinakatawan ng isang hiwalay na observation na may natatanging featureName.

Pinakamahuhusay na kasanayan at performance

VNCoreMLRequest ay na-optimize para sa pagtatrabaho sa Neural Engine (A12+), GPU at CPU. Awtomatikong pinipili ng Vision ang pinakamahusay na device para sa pagpapatakbo ng model depende sa uri at laki nito. Gayunpaman, ang performance ay maaaring mapabuti pa sa tamang configuration.

Pamamahala ng memorya

Mga Core ML model ay nilo-load sa memory sa unang VNCoreMLRequest at nananatili doon hanggang sa pag-unload ng application. Para sa mga model na mas malaki sa 200 MB, inirerekomenda ng Apple na i-load ang mga ito on demand at i-unload sa pamamagitan ng MLModel.release(). Ang VNCoreMLModel mismo ang namamahala ng caching, ngunit maaari mong kontrolin ito sa pamamagitan ng autoreleasepool.

Batch processing

Para sa batch processing ng mga larawan, gumawa ng isang VNCoreMLRequest at gamitin itong muli sa iba't ibang VNImageRequestHandler. Huwag gumawa ng bagong VNCoreMLRequest para sa bawat larawan — ito ay magpapabagal sa pagproseso dahil sa muling pag-load ng model. Ang muling paggamit ng request ay nagbibigay ng pagtaas ng performance na hanggang 40% kapag nagproseso ng 10+ na larawan.

// Tama: isang request para sa lahat ng larawan
let batchSize = 20
let batchRequest = VNCoreMLRequest(model: model)

for i in 0..<batchSize {
    let handler = VNImageRequestHandler(
        cgImage: images[i],
        options: [:])
    try handler.perform([batchRequest])
    // Ang batchRequest.results ay ina-update sa bawat tawag
}

Pagpili ng device: bilang default, pinipili ng Vision ang Neural Engine para sa mga compatible na model sa A12+ na device. Kung hindi sinusuportahan ng model ang Neural Engine, gumagamit ang Vision ng GPU o CPU. Maaari mong pilitin na tukuyin ang device sa pamamagitan ng MLModelConfiguration.computeUnits, ngunit inirerekomenda ng Apple na iwanan ang awtomatikong pagpili.

Ayon sa Apple Performance Benchmarks 2024, ang VNCoreMLRequest sa Neural Engine (iPhone 15 Pro) ay nagproseso ng klasipikasyon ng MobileNetV2 sa loob ng 3–5 ms, sa GPU — 8–12 ms, sa CPU — 20–30 ms. Ang pagkakaiba ay nagiging kritikal para sa real-time na application na nagproseso ng 30+ frame bawat segundo.