Core AI Model Authoring and Optimization

import SwiftUI
import CoreML
import CoreImage

// MARK: - CoreML model wrapper for a Core AI–authored .aimodel asset
// The .aimodel is produced offline by the coreai-torch Python pipeline:
//   exported = torch.export.export(model, example_inputs)
//   core_ai_program = TorchConverter().convert(exported, ...)
//   compressed = Quantizer(config=presets.w4).finalize(core_ai_program)
//   asset = compressed.specialize()          // writes MyModel.aimodel
// Then add MyModel.mlpackage to your Xcode project.

struct CoreAIInferenceView: View {
    @State private var resultLabel: String = "Tap Run to infer"
    @State private var isRunning = false

    var body: some View {
        VStack(spacing: 24) {
            Text("Core AI On-Device Inference")
                .font(.headline)

            Text(resultLabel)
                .multilineTextAlignment(.center)
                .padding()

            Button(isRunning ? "Running…" : "Run Model") {
                Task { await runInference() }
            }
            .buttonStyle(.borderedProminent)
            .disabled(isRunning)
        }
        .padding()
    }

    @MainActor
    private func runInference() async {
        isRunning = true
        defer { isRunning = false }

        do {
            // Load the Core AI–authored model compiled from the .mlpackage
            let config = MLModelConfiguration()
            config.computeUnits = .all          // ANE + GPU + CPU

            // MLModel(contentsOf:configuration:) loads any .mlmodelc
            // produced from a coreai-torch conversion output.
            guard let modelURL = Bundle.main.url(
                forResource: "SAM3_w4",
                withExtension: "mlmodelc"
            ) else {
                resultLabel = "Model file not found in bundle."
                return
            }

            let model = try await MLModel.load(
                contentsOf: modelURL,
                configuration: config
            )

            // Build a feature provider with the inputs the model expects.
            // Input names come from the TorchConverter call:
            //   TorchConverter().convert(exported, input_names:["pixel_values",
            //                            "input_ids", "attention_mask"])
            let pixelValues  = try MLMultiArray(shape: [1, 3, 1024, 1024],
                                                dataType: .float16)
            let inputIDs     = try MLMultiArray(shape: [1, 77],
                                                dataType: .int32)
            let attentionMask = try MLMultiArray(shape: [1, 77],
                                                 dataType: .int32)

            // Fill with dummy data for demonstration
            for i in 0 ..< pixelValues.count  { pixelValues[i]   = 0.5 }
            for i in 0 ..< inputIDs.count     { inputIDs[i]      = 0   }
            for i in 0 ..< attentionMask.count { attentionMask[i] = 1  }

            let provider = try MLDictionaryFeatureProvider(dictionary: [
                "pixel_values":   MLFeatureValue(multiArray: pixelValues),
                "input_ids":      MLFeatureValue(multiArray: inputIDs),
                "attention_mask": MLFeatureValue(multiArray: attentionMask)
            ])

            let startTime = Date()
            let output    = try await model.prediction(from: provider)
            let elapsed   = Date().timeIntervalSince(startTime)

            // The w4-compressed SAM3 outputs a segmentation mask tensor.
            if let maskArray = output.featureValue(for: "pred_masks")?.multiArrayValue {
                resultLabel = "✅ Inference OK in \(String(format: "%.2f", elapsed))s\n" +
                              "Mask shape: \(maskArray.shape)\n" +
                              "Model: SAM3 w4 (≈430 MB, down from 3 GB)"
            } else {
                resultLabel = "⚠️ Output tensor 'pred_masks' not found."
            }
        } catch {
            resultLabel = "❌ Error: \(error.localizedDescription)"
        }
    }
}

#Preview {
    CoreAIInferenceView()
}