On-Device ML for Apple Platforms Questions

import CoreML
import UIKit

func runBatchInference(model: MLModel, tensors: [MLMultiArray], batchSize: Int = 8, completion: @escaping ([Any]) -> Void) {
    let workQueue = DispatchQueue(label: "ml.inference", qos: .userInitiated, attributes: .concurrent)
    let group = DispatchGroup()
    var results: [Any] = []
    let resultsLock = NSLock()

    // Split tensors into chunks
    let batches = stride(from: 0, to: tensors.count, by: batchSize).map {
        Array(tensors[$0..<min($0 + batchSize, tensors.count)])
    }

    for batch in batches {
        group.enter()
        workQueue.async {
            // Build MLBatchProvider
            let providers = batch.enumerated().map { (idx, array) -> MLFeatureProvider in
                // Replace "image" with your model's input name
                return try! MLDictionaryFeatureProvider(dictionary: ["image": array])
            }
            let batchProvider = MLArrayBatchProvider(array: providers)

            do {
                // Synchronous batch prediction call (runs on this background thread)
                let batchResult = try model.predictions(from: batchProvider)
                // Extract outputs (example assumes output named "classLabel" or "probabilities")
                for i in 0..<batchResult.count {
                    let out = batchResult.features(at: i)
                    let value = out.featureValue(for: "classLabel")?.stringValue ?? out.featureValue(for: "probabilities")?.dictionaryValue
                    resultsLock.lock(); results.append(value as Any); resultsLock.unlock()
                }
            } catch {
                resultsLock.lock(); results.append(error); resultsLock.unlock()
            }
            group.leave()
        }
    }

    group.notify(queue: .main) {
        // Safe UI update on main thread
        completion(results)
    }
}

import CoreML
import Foundation
import Vision

// 1. Prepare labeled examples as MLFeatureProvider
func makeExample(imagePixelBuffer: CVPixelBuffer, label: String) -> MLFeatureProvider {
    let dict: [String: Any] = [
        "image": imagePixelBuffer,
        "label": label
    ]
    return try! MLDictionaryFeatureProvider(dictionary: dict)
}

// 2. Create batch provider from examples
let examples: [MLFeatureProvider] = userImages.enumerated().map { idx, (pb, label) in
    return makeExample(imagePixelBuffer: pb, label: label)
}
let batch = MLArrayBatchProvider(array: examples)

// 3. Configure update task
let updateParams: [MLParameterKey: Any] = [
    .epochs: 3,
    .miniBatchSize: 8,
    .learningRate: 1e-4
]
let config = MLModelConfiguration()
config.parameters = updateParams

// Load model for updating (must be updatable)
let modelURL = Bundle.main.url(forResource: "ImageClassifier", withExtension: "mlmodelc")!
let updateTask = try MLUpdateTask(forModelAt: modelURL,
                                  trainingData: batch,
                                  configuration: config,
                                  progressHandlers: .init(forEvents: [.trainingBegin, .epochEnd, .miniBatchEnd]) { context in
    // progress handler runs on background thread
    if context.event == .epochEnd {
        print("Epoch \(context.metrics[.epochIndex] ?? "n/a") complete")
    }
} completionHandler: { context in
    // 4. Completion: get updated model and persist safely
    guard let updatedModel = context.model else { return }
    let fm = FileManager.default
    let tmpURL = fm.temporaryDirectory.appendingPathComponent("updated.mlmodelc")
    // remove any existing temp file
    try? fm.removeItem(at: tmpURL)
    do {
        try updatedModel.write(to: tmpURL)
        // Atomically replace existing model in app container (use migration strategy)
        let targetURL = getPersistedModelURL() // implement to point into Documents or Application Support
        let backupURL = targetURL.appendingPathExtension("bak")
        // backup existing
        if fm.fileExists(atPath: targetURL.path) {
            try? fm.removeItem(at: backupURL)
            try fm.moveItem(at: targetURL, to: backupURL)
        }
        // move new model into place
        try fm.moveItem(at: tmpURL, to: targetURL)
        // remove backup on success
        try? fm.removeItem(at: backupURL)
        print("Updated model persisted to \(targetURL)")
    } catch {
        print("Failed to persist updated model: \(error)")
    }
}
)

// 5. Run update on background thread
DispatchQueue.global(qos: .userInitiated).async {
    updateTask.resume()
}