Core ML × Antigravity — to On-Device AI Development

# pytorch_to_coreml.py
import torch
import torch.nn as nn
import coremltools
from PIL import Image
import numpy as np
 
# Load or define your PyTorch model
model = torch.hub.load('pytorch/vision:v0.10.0', 'resnet18', pretrained=True)
model.eval()
 
# Create dummy input (batch=1, 3 channels, 224×224)
dummy_input = torch.randn(1, 3, 224, 224)
 
# Export to ONNX (intermediate format)
onnx_path = "resnet18.onnx"
torch.onnx.export(
    model,
    dummy_input,
    onnx_path,
    input_names=["image"],
    output_names=["predictions"],
    opset_version=13,
)
 
# Convert ONNX to Core ML
import onnx
onnx_model = onnx.load(onnx_path)
 
coreml_model = coremltools.convert(
    onnx_model,
    source="onnx",
    inputs=[coremltools.ImageType(name="image", shape=(1, 3, 224, 224))],
    outputs=[coremltools.NeuralNetworkClassifierOutput("predictions")],
    compute_units=coremltools.ComputeUnit.CPU_AND_NE,  # Prioritize Neural Engine
)
 
# Add metadata
coreml_model.author = "Your Company"
coreml_model.short_description = "ResNet-18 Image Classifier"
coreml_model.input_description["image"] = "RGB image, 224×224 pixels"
coreml_model.output_description["predictions"] = "Probability distribution over 1000 classes"
 
# Save
coreml_model.save("ResNet18.mlmodel")
print("✅ Successfully created ResNet18.mlmodel")

import SwiftUI
import Vision
import CoreML
 
struct ContentView: View {
    @State private var selectedImage: UIImage?
    @State private var predictionResult: String = "Select an image"
    @State private var isLoading = false
    @State private var inferenceTime: Double = 0
 
    var body: some View {
        VStack(spacing: 20) {
            if let image = selectedImage {
                Image(uiImage: image)
                    .resizable()
                    .scaledToFit()
                    .frame(height: 300)
            } else {
                Rectangle()
                    .fill(Color.gray.opacity(0.3))
                    .frame(height: 300)
                    .overlay(Text("Select Image"))
            }
 
            VStack(alignment: .leading, spacing: 8) {
                Text(predictionResult)
                    .font(.headline)
                if inferenceTime > 0 {
                    Text("Inference: \(String(format: "%.1f", inferenceTime))ms")
                        .font(.caption)
                        .foregroundColor(.gray)
                }
            }
            .padding()
            .background(Color.blue.opacity(0.1))
            .cornerRadius(8)
 
            if isLoading {
                ProgressView()
            }
 
            HStack(spacing: 10) {
                Button("Camera") {
                    // Open camera
                }
                .buttonStyle(.bordered)
 
                Button("Photo Library") {
                    // Open photo picker
                }
                .buttonStyle(.bordered)
            }
 
            Spacer()
        }
        .padding()
    }
}
 
// Core ML inference class
class ImageClassifier {
    let model = ResNet18()  // Auto-generated from ResNet18.mlmodel
 
    func classify(_ image: UIImage) -> ClassificationResult? {
        // 1. Preprocess image (resize to 224×224, normalize)
        guard let pixelBuffer = image.resized(to: CGSize(width: 224, height: 224))
            .toCVPixelBuffer() else {
            return nil
        }
 
        // 2. Measure inference time
        let startTime = Date()
 
        // 3. Run Core ML inference
        do {
            let output = try model.prediction(image: pixelBuffer)
            let inferenceTime = Date().timeIntervalSince(startTime) * 1000
 
            let probabilities = output.predictions  // Dictionary of class → probability
 
            // 4. Extract top prediction
            if let topPrediction = probabilities.max(by: { $0.value < $1.value }) {
                return ClassificationResult(
                    className: topPrediction.key,
                    confidence: topPrediction.value,
                    inferenceTime: inferenceTime
                )
            }
        } catch {
            print("Core ML Inference Error: \(error.localizedDescription)")
        }
 
        return nil
    }
}
 
struct ClassificationResult {
    let className: String
    let confidence: Float
    let inferenceTime: Double
}
 
// Helper: UIImage → CVPixelBuffer conversion
extension UIImage {
    func resized(to size: CGSize) -> UIImage? {
        let renderer = UIGraphicsImageRenderer(size: size)
        return renderer.image { _ in
            self.draw(in: CGRect(origin: .zero, size: size))
        }
    }
 
    func toCVPixelBuffer() -> CVPixelBuffer? {
        let attrs = [
            kCVPixelBufferCGImageCompatibilityKey: kCFBooleanTrue,
            kCVPixelBufferCGBitmapContextCompatibilityKey: kCFBooleanTrue
        ] as CFDictionary
 
        var pixelBuffer: CVPixelBuffer?
        let status = CVPixelBufferCreate(
            kCFAllocatorDefault,
            Int(self.size.width),
            Int(self.size.height),
            kCVPixelFormatType_32ARGB,
            attrs,
            &pixelBuffer
        )
 
        guard status == kCVReturnSuccess else { return nil }
 
        CVPixelBufferLockBaseAddress(pixelBuffer!, [])
        defer { CVPixelBufferUnlockBaseAddress(pixelBuffer!, []) }
 
        let context = CGContext(
            data: CVPixelBufferGetBaseAddress(pixelBuffer!),
            width: Int(self.size.width),
            height: Int(self.size.height),
            bitsPerComponent: 8,
            bytesPerRow: CVPixelBufferGetBytesPerRow(pixelBuffer!),
            space: CGColorSpaceCreateDeviceRGB(),
            bitmapInfo: CGImageAlphaInfo.noneSkipFirst.rawValue
        )
 
        if let cgImage = self.cgImage, let context = context {
            context.draw(cgImage, in: CGRect(origin: .zero, size: self.size))
        }
 
        return pixelBuffer
    }
}

import TensorFlowLite
 
class ImageClassifierLiteRT {
    let interpreter: Interpreter
 
    init?(modelPath: String) {
        // Configure Core ML delegate
        var options = CoreMLDelegate.Options()
        options.enabledDevices = [.neuralEngine, .gpu, .cpu]
 
        guard let coreMLDelegate = CoreMLDelegate(options: options) else {
            return nil
        }
 
        // Initialize interpreter with delegate
        var interpreterOptions = InterpreterOptions()
        interpreterOptions.addDelegate(coreMLDelegate)
 
        guard let interpreter = try? Interpreter(
            modelPath: modelPath,
            options: interpreterOptions
        ) else {
            return nil
        }
 
        self.interpreter = interpreter
    }
 
    func classify(_ pixelBuffer: CVPixelBuffer) -> ClassificationResult? {
        do {
            try interpreter.resizeInput(at: 0, to: Tensor(shape: [1, 224, 224, 3]))
            try interpreter.invoke()
 
            let output = try interpreter.output(at: 0)
            let probabilities = output.data.withUnsafeBytes { buffer in
                Array(buffer.assumingMemoryBound(to: Float.self))
            }
 
            if let maxIndex = probabilities.firstIndex(of: probabilities.max() ?? 0) {
                let confidence = probabilities[maxIndex]
                return ClassificationResult(
                    className: "Class \(maxIndex)",
                    confidence: confidence,
                    inferenceTime: 0
                )
            }
        } catch {
            print("LiteRT Inference Error: \(error)")
        }
 
        return nil
    }
}

import CoreML
 
/// Downloads a remote .mlpackage, compiles it, and keeps the compiled
/// artifact (.mlmodelc) as a persistent cache.
actor RemoteModelLoader {
    enum LoadError: Error {
        case downloadFailed(statusCode: Int)
    }
 
    private let remoteURL: URL
    private let cacheName: String
    private var cached: MLModel?
 
    init(remoteURL: URL, cacheName: String) {
        self.remoteURL = remoteURL
        self.cacheName = cacheName
    }
 
    /// Store under Application Support. Caches can be purged by the system.
    private var compiledURL: URL {
        let base = FileManager.default.urls(
            for: .applicationSupportDirectory, in: .userDomainMask
        )[0].appendingPathComponent("Models", isDirectory: true)
        return base.appendingPathComponent("\(cacheName).mlmodelc", isDirectory: true)
    }
 
    func model(configuration: MLModelConfiguration = .init()) async throws -> MLModel {
        if let cached { return cached }
 
        // 1. Use the cached artifact when it opens cleanly. A compiled model can
        //    stop loading after an OS upgrade, so treat failure as "refetch",
        //    not as a fatal error.
        if FileManager.default.fileExists(atPath: compiledURL.path),
           let model = try? MLModel(contentsOf: compiledURL, configuration: configuration) {
            cached = model
            return model
        }
 
        // 2. Download
        let (tempURL, response) = try await URLSession.shared.download(from: remoteURL)
        let status = (response as? HTTPURLResponse)?.statusCode ?? -1
        guard status == 200 else { throw LoadError.downloadFailed(statusCode: status) }
 
        // 3. Compile. The returned URL points into a temporary directory —
        //    hold onto it as-is and it will be gone by the next launch.
        let compiled = try await MLModel.compileModel(at: tempURL)
 
        let fm = FileManager.default
        try fm.createDirectory(
            at: compiledURL.deletingLastPathComponent(),
            withIntermediateDirectories: true
        )
        if fm.fileExists(atPath: compiledURL.path) {
            try fm.removeItem(at: compiledURL)
        }
        try fm.moveItem(at: compiled, to: compiledURL)
 
        // 4. Re-downloadable derived data: keep it out of backups.
        var values = URLResourceValues()
        values.isExcludedFromBackup = true
        var mutableURL = compiledURL
        try? mutableURL.setResourceValues(values)
 
        let model = try MLModel(contentsOf: compiledURL, configuration: configuration)
        cached = model
        return model
    }
}

let config = MLModelConfiguration()
config.computeUnits = .cpuAndNeuralEngine
 
let model = try await loader.model(configuration: config)
 
// The first prediction includes lazy model loading.
// Warm it once with dummy input before the user touches anything.
Task.detached(priority: .utility) {
    _ = try? await warmUp(model)
}

class HybridAnalyzer {
    let onDeviceClassifier = ImageClassifier()
    let cloudAPI = CloudAnalysisAPI()
 
    func analyze(_ image: UIImage) async -> AnalysisResult {
        // Step 1: Fast on-device inference
        guard let deviceResult = onDeviceClassifier.classify(image) else {
            // Fallback to cloud on error
            return try await cloudAPI.analyze(image)
        }
 
        // Step 2: Decision logic based on confidence
        if deviceResult.confidence > 0.85 {
            // High confidence: return device result
            return AnalysisResult(
                prediction: deviceResult.className,
                confidence: deviceResult.confidence,
                source: .device,
                latency: deviceResult.inferenceTime
            )
        } else {
            // Low confidence: escalate to cloud
            return try await cloudAPI.analyze(image)
        }
    }
}
 
struct AnalysisResult {
    let prediction: String
    let confidence: Float
    let source: Source
    let latency: Double
 
    enum Source {
        case device
        case cloud
    }
}

pip install --upgrade coremltools==7.1

coreml_model = coremltools.convert(
    ...,
    compute_units=coremltools.ComputeUnit.CPU_AND_NE,
    minimum_deployment_target=coremltools.target.iOS16
)

let resized = image.resized(to: CGSize(width: 224, height: 224))