# Vision Framework en CoreML: iOS-sollicitatievragen over on-device ML

> Bereid je voor op iOS-sollicitatiegesprekken met essentiële vragen over Vision Framework en CoreML: beeldherkenning, objectdetectie en on-device ML.

- Published: 2026-03-07
- Updated: 2026-04-29
- Author: SharpSkill
- Tags: vision, coreml, ios, machine-learning, interview
- Reading time: 14 min

---

On-device machine learning vormt een belangrijk concurrentievoordeel voor moderne iOS-applicaties. Vision Framework en CoreML maken het mogelijk om modellen rechtstreeks op het apparaat uit te voeren, wat dataprivacy en realtime prestaties garandeert. Deze sollicitatievragen behandelen de essentiële concepten die elke senior iOS-ontwikkelaar moet beheersen.

> **Structuur van de gids**
>
> De vragen zijn georganiseerd per thema: CoreML-fundamenten, Vision Framework, prestatieoptimalisatie en praktijkgevallen. Elk antwoord bevat moderne Swift-code en gedetailleerde uitleg.

## CoreML-fundamenten

### 1. Wat is CoreML en wat zijn de voordelen?

CoreML is het framework van Apple voor het integreren van machine learning-modellen in iOS-, macOS-, watchOS- en tvOS-applicaties. Het optimaliseert modellen automatisch voor Apple-hardware (CPU, GPU, Neural Engine) en garandeert on-device uitvoering zonder netwerkverbinding.

De belangrijkste voordelen zijn dataprivacy (geen data verlaat het apparaat), lagere latency (geen network round-trip) en automatische optimalisatie voor de Neural Engine op Apple Silicon-chips.

```swift
// CoreMLBasics.swift
import CoreML

// Loading a compiled CoreML model (.mlmodelc)
class ImageClassifier {
    // Model is compiled at build time to optimize loading
    private let model: VNCoreMLModel

    init() throws {
        // Configuration to use Neural Engine if available
        let config = MLModelConfiguration()
        config.computeUnits = .all  // CPU + GPU + Neural Engine

        // Load model with custom configuration
        let mlModel = try MobileNetV2(configuration: config).model
        model = try VNCoreMLModel(for: mlModel)
    }

    // Method to classify an image
    func classify(image: CGImage) async throws -> [(String, Float)] {
        // Create Vision request with CoreML model
        let request = VNCoreMLRequest(model: model)
        request.imageCropAndScaleOption = .centerCrop

        // Handler to process the image
        let handler = VNImageRequestHandler(cgImage: image, options: [:])
        try handler.perform([request])

        // Extract results
        guard let results = request.results as? [VNClassificationObservation] else {
            return []
        }

        // Return top 5 predictions with confidence
        return results.prefix(5).map { ($0.identifier, $0.confidence) }
    }
}
```

### 2. Hoe converteer je een TensorFlow- of PyTorch-model naar CoreML?

De conversie gebruikt coremltools, een officieel Python-pakket van Apple. Het ondersteunt TensorFlow, PyTorch, ONNX en andere populaire formaten. De conversie kan optimalisaties zoals kwantisatie omvatten om de modelgrootte te verkleinen.

```python
# convert_model.py
import coremltools as ct
import torch

# Conversion from PyTorch
class MyClassifier(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = torch.nn.Conv2d(3, 64, 3)
        self.fc = torch.nn.Linear(64, 10)

    def forward(self, x):
        x = self.conv(x)
        x = x.mean([2, 3])  # Global average pooling
        return self.fc(x)

# Example input for tracing
example_input = torch.rand(1, 3, 224, 224)

# Trace the PyTorch model
traced_model = torch.jit.trace(MyClassifier(), example_input)

# Convert to CoreML with metadata
mlmodel = ct.convert(
    traced_model,
    inputs=[ct.ImageType(name="image", shape=(1, 3, 224, 224))],
    classifier_config=ct.ClassifierConfig(["cat", "dog", "bird"]),
    minimum_deployment_target=ct.target.iOS17
)

# Save model with compression
mlmodel.save("MyClassifier.mlpackage")
```

Het `.mlpackage`-model kan vervolgens rechtstreeks aan het Xcode-project worden toegevoegd, dat automatisch een getypeerde Swift-klasse genereert.

### 3. Wat is het verschil tussen MLModel en VNCoreMLModel?

`MLModel` is de basisklasse van CoreML voor het laden en uitvoeren van ML-modellen. `VNCoreMLModel` is een wrapper waarmee een CoreML-model met Vision Framework kan worden gebruikt, met automatische beeldpreprocessing en integratie met Vision-pipelines.

```swift
// MLModelVsVNCoreML.swift
import CoreML
import Vision

// Direct MLModel usage (low level)
func predictWithMLModel(features: MLFeatureProvider) async throws -> String {
    let config = MLModelConfiguration()
    let model = try MyModel(configuration: config)

    // Direct prediction with feature provider
    let prediction = try model.prediction(from: features)

    // Manual output access
    guard let output = prediction.featureValue(for: "classLabel")?.stringValue else {
        throw PredictionError.invalidOutput
    }
    return output
}

// Usage with VNCoreMLModel (high level, recommended for images)
func predictWithVision(image: CGImage) async throws -> [VNClassificationObservation] {
    let config = MLModelConfiguration()
    let mlModel = try MyModel(configuration: config).model

    // Wrapper for use with Vision
    let visionModel = try VNCoreMLModel(for: mlModel)

    // Vision automatically handles resizing and preprocessing
    let request = VNCoreMLRequest(model: visionModel)
    request.imageCropAndScaleOption = .scaleFill

    let handler = VNImageRequestHandler(cgImage: image)
    try handler.perform([request])

    return request.results as? [VNClassificationObservation] ?? []
}
```

> **Wanneer welke gebruiken?**
>
> Direct `MLModel` voor tabulaire data of niet-beeldgerelateerde input. `VNCoreMLModel` voor alles wat met beelden te maken heeft, omdat Vision automatisch formaatconversies en preprocessing afhandelt.

### 4. Hoe ga je om met verschillende iOS-versies bij CoreML?

CoreML evolueert met elke iOS-versie. Het is essentieel om een minimaal deployment target te definiëren tijdens de conversie en functies te beheren die niet beschikbaar zijn in oudere versies.

```swift
// CoreMLVersioning.swift
import CoreML

class AdaptiveMLManager {
    // Check model capabilities based on iOS version
    func loadOptimalModel() throws -> MLModel {
        let config = MLModelConfiguration()

        // iOS 17+: Optimized Neural Engine with compute budget
        if #available(iOS 17, *) {
            config.computeUnits = .cpuAndNeuralEngine
            // New in iOS 17: compute power limit
            config.allowLowPrecisionAccumulationOnGPU = true
            return try AdvancedModel(configuration: config).model
        }
        // iOS 16: Enhanced GPU support
        else if #available(iOS 16, *) {
            config.computeUnits = .all
            return try StandardModel(configuration: config).model
        }
        // iOS 15: CPU only fallback for reliability
        else {
            config.computeUnits = .cpuOnly
            return try LegacyModel(configuration: config).model
        }
    }

    // Check if Neural Engine is available
    var hasNeuralEngine: Bool {
        if #available(iOS 16, *) {
            // Devices with A11+ have Neural Engine
            var sysinfo = utsname()
            uname(&sysinfo)
            let machine = String(bytes: Data(bytes: &sysinfo.machine,
                count: Int(_SYS_NAMELEN)), encoding: .ascii)?
                .trimmingCharacters(in: .controlCharacters) ?? ""

            // iPhone X and later have Neural Engine
            return machine.contains("iPhone10") ||
                   machine.hasPrefix("iPhone1") && machine.count > 7
        }
        return false
    }
}
```

## Vision Framework

### 5. Welke soorten requests ondersteunt Vision Framework?

Vision Framework biedt een breed scala aan requests voor beeldanalyse. De belangrijkste categorieën zijn gezichtsdetectie, tekstherkenning (OCR), objectdetectie, object tracking in video en beeldgelijkenisanalyse.

```swift
// VisionRequests.swift
import Vision

class VisionAnalyzer {
    // Face detection with landmarks
    func detectFaces(in image: CGImage) async throws -> [VNFaceObservation] {
        let request = VNDetectFaceLandmarksRequest()
        request.revision = VNDetectFaceLandmarksRequestRevision3

        let handler = VNImageRequestHandler(cgImage: image)
        try handler.perform([request])

        return request.results ?? []
    }

    // Text recognition (OCR)
    func recognizeText(in image: CGImage) async throws -> [String] {
        let request = VNRecognizeTextRequest()
        request.recognitionLevel = .accurate  // .fast for real-time
        request.recognitionLanguages = ["en-US", "fr-FR"]
        request.usesLanguageCorrection = true

        let handler = VNImageRequestHandler(cgImage: image)
        try handler.perform([request])

        return request.results?.compactMap { observation in
            observation.topCandidates(1).first?.string
        } ?? []
    }

    // Object detection and classification
    func detectObjects(in image: CGImage) async throws -> [VNRecognizedObjectObservation] {
        // Use a CoreML model for detection
        let config = MLModelConfiguration()
        let detector = try YOLOv8(configuration: config)
        let visionModel = try VNCoreMLModel(for: detector.model)

        let request = VNCoreMLRequest(model: visionModel)
        request.imageCropAndScaleOption = .scaleFill

        let handler = VNImageRequestHandler(cgImage: image)
        try handler.perform([request])

        return request.results as? [VNRecognizedObjectObservation] ?? []
    }

    // Compute similarity between images
    func computeSimilarity(image1: CGImage, image2: CGImage) async throws -> Float {
        // Generate feature prints for both images
        let request = VNGenerateImageFeaturePrintRequest()

        let handler1 = VNImageRequestHandler(cgImage: image1)
        try handler1.perform([request])
        guard let print1 = request.results?.first else { throw VisionError.noResults }

        let handler2 = VNImageRequestHandler(cgImage: image2)
        try handler2.perform([request])
        guard let print2 = request.results?.first else { throw VisionError.noResults }

        // Compute distance between embeddings
        var distance: Float = 0
        try print1.computeDistance(&distance, to: print2)

        // Convert distance to similarity score (0-1)
        return 1.0 / (1.0 + distance)
    }
}
```

### 6. Hoe implementeer je realtime object tracking met Vision?

Object tracking gebruikt `VNTrackObjectRequest` om een gedetecteerd object door videoframes te volgen. De initialisatie gebeurt met een detection observation, daarna gebruiken de volgende frames dezelfde request voor de tracking.

```swift
// ObjectTracking.swift
import Vision
import AVFoundation

class ObjectTracker: NSObject {
    private var trackingRequest: VNTrackObjectRequest?
    private let sequenceHandler = VNSequenceRequestHandler()

    // Callback to notify position updates
    var onTrackingUpdate: ((CGRect) -> Void)?
    var onTrackingLost: (() -> Void)?

    // Initialize tracking with an initial detection
    func startTracking(observation: VNDetectedObjectObservation) {
        // Create tracking request from observation
        trackingRequest = VNTrackObjectRequest(
            detectedObjectObservation: observation
        ) { [weak self] request, error in
            self?.handleTrackingResult(request: request, error: error)
        }

        // Configure tracking
        trackingRequest?.trackingLevel = .accurate  // .fast for 60fps
    }

    // Process each new video frame
    func processFrame(_ pixelBuffer: CVPixelBuffer) {
        guard let request = trackingRequest else { return }

        do {
            // Sequence handler maintains context between frames
            try sequenceHandler.perform([request], on: pixelBuffer)
        } catch {
            onTrackingLost?()
            trackingRequest = nil
        }
    }

    private func handleTrackingResult(request: VNRequest, error: Error?) {
        guard let result = request.results?.first as? VNDetectedObjectObservation else {
            onTrackingLost?()
            return
        }

        // Check tracking confidence
        if result.confidence < 0.3 {
            onTrackingLost?()
            trackingRequest = nil
            return
        }

        // Update request for next frame
        trackingRequest = VNTrackObjectRequest(detectedObjectObservation: result) {
            [weak self] request, error in
            self?.handleTrackingResult(request: request, error: error)
        }

        // Notify new position (normalized coordinates)
        DispatchQueue.main.async { [weak self] in
            self?.onTrackingUpdate?(result.boundingBox)
        }
    }
}

// Integration with AVCaptureSession
extension ObjectTracker: AVCaptureVideoDataOutputSampleBufferDelegate {
    func captureOutput(
        _ output: AVCaptureOutput,
        didOutput sampleBuffer: CMSampleBuffer,
        from connection: AVCaptureConnection
    ) {
        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
            return
        }
        processFrame(pixelBuffer)
    }
}
```

### 7. Hoe optimaliseer je de Vision-prestaties voor realtime verwerking?

De optimalisatie omvat verschillende technieken: het juiste herkenningsniveau gebruiken, frames verwerken op een aparte queue en het aantal gelijktijdige requests beperken. De keuze tussen nauwkeurigheid en snelheid hangt af van de use case.

```swift
// VisionOptimization.swift
import Vision
import AVFoundation

class OptimizedVisionPipeline {
    // Dedicated queue for Vision processing (avoids main thread)
    private let processingQueue = DispatchQueue(
        label: "com.app.vision",
        qos: .userInteractive,
        attributes: .concurrent
    )

    // Limit number of simultaneously processed frames
    private let semaphore = DispatchSemaphore(value: 2)

    // Reuse requests to avoid allocations
    private lazy var textRequest: VNRecognizeTextRequest = {
        let request = VNRecognizeTextRequest()
        request.recognitionLevel = .fast  // .accurate if precision > speed
        request.usesLanguageCorrection = false  // Disable for +20% perf
        request.minimumTextHeight = 0.05  // Ignore text too small
        return request
    }()

    // Reuse sequence handler for tracking
    private let sequenceHandler = VNSequenceRequestHandler()

    // Optimized frame processing
    func processFrame(_ pixelBuffer: CVPixelBuffer) {
        // Skip if pipeline is saturated
        guard semaphore.wait(timeout: .now()) == .success else {
            return  // Drop frame rather than block
        }

        processingQueue.async { [weak self] in
            defer { self?.semaphore.signal() }

            guard let self = self else { return }

            do {
                // Use sequence handler for better performance
                try self.sequenceHandler.perform(
                    [self.textRequest],
                    on: pixelBuffer,
                    orientation: .up
                )

                // Process results
                if let results = self.textRequest.results {
                    self.handleResults(results)
                }
            } catch {
                print("Vision error: \(error)")
            }
        }
    }

    // Batch processing for static images
    func processImages(_ images: [CGImage]) async throws -> [[VNObservation]] {
        // Parallel processing with TaskGroup
        try await withThrowingTaskGroup(of: (Int, [VNObservation]).self) { group in
            for (index, image) in images.enumerated() {
                group.addTask {
                    let handler = VNImageRequestHandler(cgImage: image)
                    let request = VNDetectFaceRectanglesRequest()
                    try handler.perform([request])
                    return (index, request.results ?? [])
                }
            }

            // Collect results in original order
            var results = [[VNObservation]](repeating: [], count: images.count)
            for try await (index, observations) in group {
                results[index] = observations
            }
            return results
        }
    }

    private func handleResults(_ results: [VNRecognizedTextObservation]) {
        // Async processing of results
    }
}
```

### 8. Hoe implementeer je de detectie van menselijke houding met Vision?

Vision Framework iOS 14+ biedt `VNDetectHumanBodyPoseRequest` om lichaamsgewrichten te detecteren. Deze functie wordt gebruikt voor fitness-apps, AR-spellen en bewegingsanalyse.

```swift
// PoseDetection.swift
import Vision

struct DetectedPose {
    let joints: [VNHumanBodyPoseObservation.JointName: CGPoint]
    let confidence: Float

    // Calculate angle between three joints
    func angleBetween(
        _ joint1: VNHumanBodyPoseObservation.JointName,
        _ joint2: VNHumanBodyPoseObservation.JointName,
        _ joint3: VNHumanBodyPoseObservation.JointName
    ) -> Double? {
        guard let p1 = joints[joint1],
              let p2 = joints[joint2],
              let p3 = joints[joint3] else { return nil }

        let v1 = CGVector(dx: p1.x - p2.x, dy: p1.y - p2.y)
        let v2 = CGVector(dx: p3.x - p2.x, dy: p3.y - p2.y)

        let dot = v1.dx * v2.dx + v1.dy * v2.dy
        let mag1 = sqrt(v1.dx * v1.dx + v1.dy * v1.dy)
        let mag2 = sqrt(v2.dx * v2.dx + v2.dy * v2.dy)

        return acos(dot / (mag1 * mag2)) * 180 / .pi
    }
}

class PoseDetector {
    private let request = VNDetectHumanBodyPoseRequest()

    func detectPose(in image: CGImage) async throws -> DetectedPose? {
        let handler = VNImageRequestHandler(cgImage: image)
        try handler.perform([request])

        guard let observation = request.results?.first else { return nil }

        // Extract all detected joints
        var joints: [VNHumanBodyPoseObservation.JointName: CGPoint] = [:]

        // List of main joints
        let jointNames: [VNHumanBodyPoseObservation.JointName] = [
            .nose, .neck,
            .leftShoulder, .rightShoulder,
            .leftElbow, .rightElbow,
            .leftWrist, .rightWrist,
            .leftHip, .rightHip,
            .leftKnee, .rightKnee,
            .leftAnkle, .rightAnkle
        ]

        for jointName in jointNames {
            if let point = try? observation.recognizedPoint(jointName),
               point.confidence > 0.3 {
                // Convert normalized coordinates to points
                joints[jointName] = CGPoint(x: point.x, y: point.y)
            }
        }

        return DetectedPose(
            joints: joints,
            confidence: observation.confidence
        )
    }

    // Detect if person is doing a squat
    func isSquatting(pose: DetectedPose) -> Bool {
        guard let kneeAngle = pose.angleBetween(
            .leftHip, .leftKnee, .leftAnkle
        ) else { return false }

        // A squat typically has knee angle < 100°
        return kneeAngle < 100
    }
}
```

## Optimalisatie en productie

### 9. Hoe kwantiseer je een CoreML-model om de grootte te verkleinen?

Kwantisatie verlaagt de precisie van de gewichten (van Float32 naar Float16 of Int8) om de modelgrootte te verkleinen en de inferentie te versnellen. De afweging is een licht verlies aan precisie.

```python
# quantize_model.py
import coremltools as ct
from coremltools.models.neural_network import quantization_utils

# Load existing model
model = ct.models.MLModel("MyModel.mlpackage")

# Float16 quantization (recommended, good size/precision balance)
model_fp16 = ct.models.neural_network.quantization_utils.quantize_weights(
    model,
    nbits=16,
    quantization_mode="linear"
)
model_fp16.save("MyModel_FP16.mlpackage")

# Int8 quantization (smallest size, possible precision loss)
# Requires calibration dataset for best results
def calibration_data():
    import numpy as np
    for _ in range(100):
        yield {"image": np.random.rand(1, 3, 224, 224).astype(np.float32)}

model_int8 = ct.compression_utils.affine_quantize_weights(
    model,
    mode="linear_symmetric",
    dtype=ct.converters.mil.mil.types.int8
)
model_int8.save("MyModel_INT8.mlpackage")
```

```swift
// QuantizationComparison.swift
import CoreML

class ModelBenchmark {
    // Compare performance of different versions
    func benchmark() async throws {
        let configs: [(String, URL)] = [
            ("Full Precision", Bundle.main.url(forResource: "Model", withExtension: "mlmodelc")!),
            ("Float16", Bundle.main.url(forResource: "Model_FP16", withExtension: "mlmodelc")!),
            ("Int8", Bundle.main.url(forResource: "Model_INT8", withExtension: "mlmodelc")!)
        ]

        for (name, url) in configs {
            let model = try MLModel(contentsOf: url)

            // Measure average inference time over 100 iterations
            let startTime = CFAbsoluteTimeGetCurrent()
            for _ in 0..<100 {
                let input = try prepareInput()
                _ = try model.prediction(from: input)
            }
            let elapsed = CFAbsoluteTimeGetCurrent() - startTime

            // Model size
            let size = try FileManager.default.attributesOfItem(atPath: url.path)[.size] as? Int ?? 0

            print("\(name): \(elapsed/100*1000)ms/inference, \(size/1024/1024)MB")
        }
    }

    private func prepareInput() throws -> MLFeatureProvider {
        // Prepare test input
        fatalError("Implement based on model requirements")
    }
}
```

### 10. Hoe beheer je geheugen bij het verwerken van grote afbeeldingen?

Het verwerken van afbeeldingen met hoge resolutie kan geheugenpieken veroorzaken. De technieken omvatten slim downsamplen, tile-verwerking en proactief vrijgeven van resources.

```swift
// MemoryOptimization.swift
import Vision
import CoreImage

class MemoryEfficientProcessor {
    // Reusable CoreImage context to avoid allocations
    private let ciContext = CIContext(options: [
        .useSoftwareRenderer: false,
        .cacheIntermediates: false  // Reduces memory usage
    ])

    // Smart downsampling of large images
    func downsampleImage(at url: URL, to maxDimension: CGFloat) -> CGImage? {
        // Options for downsampling at read time (avoids loading full image)
        let options: [CFString: Any] = [
            kCGImageSourceCreateThumbnailFromImageAlways: true,
            kCGImageSourceThumbnailMaxPixelSize: maxDimension,
            kCGImageSourceCreateThumbnailWithTransform: true,
            kCGImageSourceShouldCacheImmediately: false
        ]

        guard let source = CGImageSourceCreateWithURL(url as CFURL, nil),
              let image = CGImageSourceCreateThumbnailAtIndex(source, 0, options as CFDictionary) else {
            return nil
        }

        return image
    }

    // Tile processing for very large images
    func processByTiles(
        image: CGImage,
        tileSize: CGSize,
        processor: (CGImage) throws -> [VNObservation]
    ) throws -> [VNObservation] {
        var allObservations: [VNObservation] = []

        let imageWidth = CGFloat(image.width)
        let imageHeight = CGFloat(image.height)

        // Iterate through image by tiles
        var y: CGFloat = 0
        while y < imageHeight {
            var x: CGFloat = 0
            while x < imageWidth {
                // Calculate tile rectangle
                let tileRect = CGRect(
                    x: x, y: y,
                    width: min(tileSize.width, imageWidth - x),
                    height: min(tileSize.height, imageHeight - y)
                )

                // Extract tile
                autoreleasepool {
                    if let tile = image.cropping(to: tileRect) {
                        do {
                            let observations = try processor(tile)

                            // Adjust coordinates relative to full image
                            let adjusted = observations.compactMap { obs -> VNObservation? in
                                guard let detected = obs as? VNDetectedObjectObservation else {
                                    return obs
                                }
                                // Recalculate bounding box in global coordinates
                                var box = detected.boundingBox
                                box.origin.x = (box.origin.x * tileRect.width + x) / imageWidth
                                box.origin.y = (box.origin.y * tileRect.height + y) / imageHeight
                                box.size.width = box.size.width * tileRect.width / imageWidth
                                box.size.height = box.size.height * tileRect.height / imageHeight

                                return detected
                            }
                            allObservations.append(contentsOf: adjusted)
                        } catch {
                            print("Tile processing error: \(error)")
                        }
                    }
                }

                x += tileSize.width * 0.9  // 10% overlap to avoid cutting objects
            }
            y += tileSize.height * 0.9
        }

        return allObservations
    }
}
```

> **Pas op voor memory leaks**
>
> Gebruik altijd `autoreleasepool` in beeldverwerkingsloops en controleer retain cycles in de closures van Vision-requests.

### 11. Hoe implementeer je een ML-pipeline met Create ML Components?

Create ML Components (iOS 16+) maakt het mogelijk om modulaire ML-pipelines te bouwen met vooraf gedefinieerde transformers. Dit is flexibeler dan traditionele monolithische modellen.

```swift
// CreateMLComponents.swift
import CreateMLComponents
import CoreImage

@available(iOS 16.0, *)
class MLPipeline {
    // Image classification pipeline with preprocessing
    func createImageClassificationPipeline() throws -> some Transformer<CGImage, String> {
        // Transformer composition
        let pipeline = ImageReader()
            .appending(ImageScaler(targetSize: .init(width: 224, height: 224)))
            .appending(ImageNormalizer(mean: [0.485, 0.456, 0.406],
                                       std: [0.229, 0.224, 0.225]))
            .appending(try ImageFeaturePrint())
            .appending(try NearestNeighborClassifier<String>
                .load(from: trainingDataURL))

        return pipeline
    }

    // Custom pipeline with custom steps
    func createCustomPipeline() -> some Transformer<CIImage, AnalysisResult> {
        // Step 1: Preprocessing
        let preprocess = CIImageTransformer { image in
            // Apply CoreImage filters
            let adjusted = image
                .applyingFilter("CIColorControls", parameters: [
                    kCIInputContrastKey: 1.2,
                    kCIInputSaturationKey: 1.1
                ])
            return adjusted
        }

        // Step 2: Detection
        let detect = VisionTransformer<CIImage, [VNFaceObservation]> { image in
            let request = VNDetectFaceRectanglesRequest()
            let handler = VNImageRequestHandler(ciImage: image)
            try handler.perform([request])
            return request.results ?? []
        }

        // Step 3: Analysis
        let analyze = ResultTransformer<[VNFaceObservation], AnalysisResult> { faces in
            AnalysisResult(
                faceCount: faces.count,
                averageConfidence: faces.map(\.confidence).reduce(0, +) / Float(faces.count)
            )
        }

        return preprocess
            .appending(detect)
            .appending(analyze)
    }
}

struct AnalysisResult {
    let faceCount: Int
    let averageConfidence: Float
}
```

### 12. Hoe test en valideer je een CoreML-model?

De tests omvatten validatie van de nauwkeurigheid, prestatietests en integratietests. Testen op verschillende apparaten en omstandigheden is cruciaal.

```swift
// MLModelTests.swift
import XCTest
import CoreML
import Vision

class CoreMLModelTests: XCTestCase {
    var model: VNCoreMLModel!

    override func setUpWithError() throws {
        let config = MLModelConfiguration()
        config.computeUnits = .cpuOnly  // Reproducible on CI
        let mlModel = try MyClassifier(configuration: config).model
        model = try VNCoreMLModel(for: mlModel)
    }

    // Accuracy test with validation dataset
    func testClassificationAccuracy() async throws {
        let testCases: [(imageName: String, expectedClass: String)] = [
            ("cat_001", "cat"),
            ("dog_001", "dog"),
            ("bird_001", "bird")
        ]

        var correct = 0
        for testCase in testCases {
            let image = try loadTestImage(named: testCase.imageName)
            let prediction = try await classify(image: image)

            if prediction == testCase.expectedClass {
                correct += 1
            }
        }

        let accuracy = Double(correct) / Double(testCases.count)
        XCTAssertGreaterThan(accuracy, 0.95, "Accuracy should be > 95%")
    }

    // Performance test (inference time)
    func testInferencePerformance() throws {
        let image = try loadTestImage(named: "test_image")

        measure(metrics: [XCTClockMetric(), XCTMemoryMetric()]) {
            let request = VNCoreMLRequest(model: model)
            let handler = VNImageRequestHandler(cgImage: image)
            try? handler.perform([request])
        }
    }

    // Transformation robustness test
    func testRobustness() async throws {
        let originalImage = try loadTestImage(named: "cat_001")
        let originalPrediction = try await classify(image: originalImage)

        // Test with rotation
        let rotated = try applyTransform(originalImage, rotation: .pi / 6)
        let rotatedPrediction = try await classify(image: rotated)
        XCTAssertEqual(originalPrediction, rotatedPrediction)

        // Test with noise
        let noisy = try addNoise(to: originalImage, intensity: 0.1)
        let noisyPrediction = try await classify(image: noisy)
        XCTAssertEqual(originalPrediction, noisyPrediction)
    }

    // Edge case handling test
    func testEdgeCases() async throws {
        // Very small image
        let smallImage = try loadTestImage(named: "tiny_10x10")
        let smallResult = try await classify(image: smallImage)
        XCTAssertNotNil(smallResult)

        // Monochrome image
        let monoImage = try loadTestImage(named: "grayscale")
        let monoResult = try await classify(image: monoImage)
        XCTAssertNotNil(monoResult)
    }

    // Helpers
    private func classify(image: CGImage) async throws -> String {
        let request = VNCoreMLRequest(model: model)
        let handler = VNImageRequestHandler(cgImage: image)
        try handler.perform([request])

        guard let results = request.results as? [VNClassificationObservation],
              let top = results.first else {
            throw TestError.noResults
        }

        return top.identifier
    }

    private func loadTestImage(named: String) throws -> CGImage {
        guard let url = Bundle(for: type(of: self))
                .url(forResource: named, withExtension: "jpg"),
              let source = CGImageSourceCreateWithURL(url as CFURL, nil),
              let image = CGImageSourceCreateImageAtIndex(source, 0, nil) else {
            throw TestError.imageNotFound
        }
        return image
    }
}
```

## Vragen over System Design

### 13. Hoe ontwerp je een on-device ML-architectuur voor een productie-app?

Een robuuste ML-architectuur scheidt de verantwoordelijkheden: model, preprocessing, postprocessing en caching. Het moet modelupdates en een soepele fallback afhandelen.

```swift
// MLArchitecture.swift
import CoreML
import Vision

// Protocol for model abstraction
protocol MLModelProvider {
    associatedtype Input
    associatedtype Output

    func predict(_ input: Input) async throws -> Output
    var modelVersion: String { get }
}

// Model manager with OTA updates
class ModelManager {
    static let shared = ModelManager()

    private var models: [String: any MLModel] = [:]
    private let modelDirectory: URL

    private init() {
        modelDirectory = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
            .appendingPathComponent("MLModels")
        try? FileManager.default.createDirectory(at: modelDirectory, withIntermediateDirectories: true)
    }

    // Load model with fallback to bundled version
    func loadModel<T: MLModel>(
        named name: String,
        type: T.Type
    ) async throws -> T {
        // Check if downloaded version exists
        let downloadedURL = modelDirectory.appendingPathComponent("\(name).mlmodelc")

        if FileManager.default.fileExists(atPath: downloadedURL.path) {
            // Validate downloaded model integrity
            do {
                let model = try await loadAndValidate(from: downloadedURL, type: type)
                return model
            } catch {
                // Fallback to bundled version if corrupted
                print("Downloaded model corrupted, falling back to bundled version")
                try? FileManager.default.removeItem(at: downloadedURL)
            }
        }

        // Load bundled version
        guard let bundledURL = Bundle.main.url(forResource: name, withExtension: "mlmodelc") else {
            throw ModelError.modelNotFound(name)
        }

        return try await loadAndValidate(from: bundledURL, type: type)
    }

    // Download and install new model version
    func updateModel(named name: String, from url: URL) async throws {
        // Download model
        let (tempURL, _) = try await URLSession.shared.download(from: url)

        // Compile model if needed
        let compiledURL: URL
        if tempURL.pathExtension == "mlmodel" {
            compiledURL = try MLModel.compileModel(at: tempURL)
        } else {
            compiledURL = tempURL
        }

        // Validate before installation
        let config = MLModelConfiguration()
        _ = try MLModel(contentsOf: compiledURL, configuration: config)

        // Install in models directory
        let destURL = modelDirectory.appendingPathComponent("\(name).mlmodelc")
        try? FileManager.default.removeItem(at: destURL)
        try FileManager.default.moveItem(at: compiledURL, to: destURL)

        // Notify app of update
        NotificationCenter.default.post(name: .modelUpdated, object: name)
    }

    private func loadAndValidate<T: MLModel>(
        from url: URL,
        type: T.Type
    ) async throws -> T {
        let config = MLModelConfiguration()
        config.computeUnits = .all

        let model = try T(contentsOf: url, configuration: config)

        // Basic model validation
        // Verify inputs/outputs match expectations

        return model
    }
}

extension Notification.Name {
    static let modelUpdated = Notification.Name("MLModelUpdated")
}
```

### 14. Hoe beheer je fouten en monitoring in productie?

Een robuust monitoringsysteem legt prestatiemetrics, fouten vast en maakt remote debugging mogelijk. Integratie met analytics-tools is essentieel.

```swift
// MLMonitoring.swift
import OSLog

class MLMonitor {
    static let shared = MLMonitor()

    private let logger = Logger(subsystem: "com.app.ml", category: "inference")
    private var metrics: [InferenceMetric] = []

    struct InferenceMetric: Codable {
        let modelName: String
        let inferenceTime: Double
        let inputSize: CGSize?
        let confidence: Float?
        let timestamp: Date
        let success: Bool
        let errorDescription: String?
    }

    // Record an inference
    func recordInference(
        model: String,
        duration: TimeInterval,
        inputSize: CGSize? = nil,
        confidence: Float? = nil,
        error: Error? = nil
    ) {
        let metric = InferenceMetric(
            modelName: model,
            inferenceTime: duration,
            inputSize: inputSize,
            confidence: confidence,
            timestamp: Date(),
            success: error == nil,
            errorDescription: error?.localizedDescription
        )

        metrics.append(metric)

        // Log for debugging
        if let error = error {
            logger.error("ML inference failed: \(model) - \(error.localizedDescription)")
        } else {
            logger.info("ML inference: \(model) completed in \(duration)s")
        }

        // Detect anomalies
        checkForAnomalies(metric)
    }

    // Wrapper for automatic measurement
    func measure<T>(
        model: String,
        inputSize: CGSize? = nil,
        operation: () async throws -> T
    ) async rethrows -> T {
        let start = CFAbsoluteTimeGetCurrent()

        do {
            let result = try await operation()
            let duration = CFAbsoluteTimeGetCurrent() - start

            recordInference(
                model: model,
                duration: duration,
                inputSize: inputSize
            )

            return result
        } catch {
            let duration = CFAbsoluteTimeGetCurrent() - start

            recordInference(
                model: model,
                duration: duration,
                inputSize: inputSize,
                error: error
            )

            throw error
        }
    }

    // Detect performance issues
    private func checkForAnomalies(_ metric: InferenceMetric) {
        // Alert if inference time exceeds threshold
        if metric.inferenceTime > 1.0 {
            logger.warning("Slow inference detected: \(metric.modelName) took \(metric.inferenceTime)s")

            // Send alert if available
            Task {
                await AnalyticsService.shared.reportAnomaly(
                    type: .slowInference,
                    details: metric
                )
            }
        }

        // Alert if confidence is too low
        if let confidence = metric.confidence, confidence < 0.5 {
            logger.info("Low confidence prediction: \(confidence) for \(metric.modelName)")
        }
    }

    // Generate performance report
    func generateReport() -> PerformanceReport {
        let recentMetrics = metrics.filter {
            $0.timestamp > Date().addingTimeInterval(-3600)  // Last hour
        }

        let avgInferenceTime = recentMetrics.map(\.inferenceTime).reduce(0, +) / Double(recentMetrics.count)
        let successRate = Double(recentMetrics.filter(\.success).count) / Double(recentMetrics.count)

        return PerformanceReport(
            totalInferences: recentMetrics.count,
            averageInferenceTime: avgInferenceTime,
            successRate: successRate,
            modelBreakdown: Dictionary(grouping: recentMetrics, by: \.modelName)
        )
    }
}

struct PerformanceReport {
    let totalInferences: Int
    let averageInferenceTime: Double
    let successRate: Double
    let modelBreakdown: [String: [MLMonitor.InferenceMetric]]
}
```

## Conclusie

Vision Framework en CoreML vormen de basis van on-device machine learning op iOS. Het beheersen van deze technologieën is essentieel voor het ontwikkelen van moderne applicaties die de privacy van gebruikers respecteren en geavanceerde ML-functies bieden.

### Reviewchecklist

- ✅ CoreML en de voordelen begrijpen (privacy, latency, offline)
- ✅ TensorFlow-/PyTorch-modellen kunnen converteren naar CoreML
- ✅ Vision-requests beheersen (gezichtsdetectie, OCR, classificatie)
- ✅ Realtime object tracking implementeren
- ✅ Prestaties optimaliseren (kwantisatie, geheugenbeheer)
- ✅ Robuuste ML-architecturen ontwerpen voor productie
- ✅ Monitoring en foutafhandeling opzetten

### Belangrijkste inzichten

De on-device prestaties hangen sterk af van de keuze tussen CPU, GPU en Neural Engine. Modelkwantisatie biedt een uitstekende afweging tussen grootte en prestaties. Monitoring in productie is cruciaal om regressies te detecteren.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/nl/blog/ios/vision-coreml-interview-on-device-ml-ios