Core ML × Antigravity — オンデバイスAI開発

# Python スクリプト: pytorch_to_coreml.py
import torch
import torch.nn as nn
from coremltools import convert
import coremltools
from PIL import Image
import numpy as np
 
# PyTorch モデルの定義（例：ResNet-18）
model = torch.hub.load('pytorch/vision:v0.10.0', 'resnet18', pretrained=True)
model.eval()
 
# ダミー入力を用意（バッチサイズ 1、RGB 224×224）
dummy_input = torch.randn(1, 3, 224, 224)
 
# ONNX 経由で Core ML に変換
onnx_path = "resnet18.onnx"
torch.onnx.export(
    model,
    dummy_input,
    onnx_path,
    input_names=["image"],
    output_names=["predictions"],
    opset_version=13,
)
 
# ONNX から Core ML に変換
from onnx import load as onnx_load
onnx_model = onnx_load(onnx_path)
 
coreml_model = 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,  # Neural Engine 優先
)
 
# メタデータを追加
coreml_model.author = "Antigravity Lab"
coreml_model.short_description = "ResNet-18 Image Classification"
coreml_model.input_description["image"] = "Input image (224×224 RGB)"
coreml_model.output_description["predictions"] = "Class probabilities"
 
# 保存
coreml_model.save("ResNet18.mlmodel")
print("✅ ResNet18.mlmodel 生成完了")

// ContentView.swift
import SwiftUI
import Vision
import CoreML
 
struct ContentView: View {
    @State private var selectedImage: UIImage?
    @State private var predictionResult: String = "画像を選択してください"
    @State private var isLoading = false
 
    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("画像を選択"))
            }
 
            Text(predictionResult)
                .font(.headline)
                .padding()
                .background(Color.blue.opacity(0.1))
                .cornerRadius(8)
 
            if isLoading {
                ProgressView()
            }
 
            HStack(spacing: 10) {
                Button("カメラで撮影") {
                    // カメラ起動
                }
                .buttonStyle(.bordered)
 
                Button("写真ライブラリから選択") {
                    // フォトピッカー起動
                }
                .buttonStyle(.bordered)
            }
 
            Spacer()
        }
        .padding()
    }
}
 
// 推論ロジック
class ImageClassifier {
    let model = ResNet18()  // 自動生成されたモデルクラス
 
    func classify(_ image: UIImage) -> String? {
        // 1. 画像前処理（224×224 にリサイズ、正規化）
        guard let pixelBuffer = image.toCVPixelBuffer() else {
            return nil
        }
 
        // 2. Core ML 推論
        do {
            let output = try model.prediction(image: pixelBuffer)
            let probabilities = output.predictions  // 1000 クラスの確率分布
 
            // 3. 最高確率のクラスを取得
            if let topPrediction = probabilities.max(by: { $0.value < $1.value }) {
                let className = topPrediction.key
                let confidence = topPrediction.value
                return "\(className): \(Int(confidence * 100))%"
            }
        } catch {
            print("推論エラー: \(error.localizedDescription)")
        }
 
        return nil
    }
}
 
// UIImage を CVPixelBuffer に変換するヘルパー
extension UIImage {
    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, let buffer = pixelBuffer else {
            return nil
        }
 
        CVPixelBufferLockBaseAddress(buffer, [])
 
        let context = CGContext(
            data: CVPixelBufferGetBaseAddress(buffer),
            width: Int(self.size.width),
            height: Int(self.size.height),
            bitsPerComponent: 8,
            bytesPerRow: CVPixelBufferGetBytesPerRow(buffer),
            space: CGColorSpaceCreateDeviceRGB(),
            bitmapInfo: CGImageAlphaInfo.noneSkipFirst.rawValue
        )
 
        if let cgImage = self.cgImage, let context = context {
            context.draw(cgImage, in: CGRect(origin: .zero, size: self.size))
        }
 
        CVPixelBufferUnlockBaseAddress(buffer, [])
        return buffer
    }
}

import TensorFlowLite
 
class ImageClassifierLiteRT {
    let interpreter: Interpreter
 
    init?(modelPath: String) {
        // Core ML delegate 設定
        var options = CoreMLDelegate.Options()
        options.enabledDevices = [.neuralEngine, .gpu, .cpu]  // 優先順位
 
        guard let coreMLDelegate = CoreMLDelegate(options: options) else {
            return nil
        }
 
        // インタープリター初期化
        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) -> String? {
        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 "Class \(maxIndex): \(Int(confidence * 100))%"
            }
        } catch {
            print("LiteRT 推論エラー: \(error)")
        }
 
        return nil
    }
}

class HybridImageAnalyzer {
    let onDeviceClassifier = ImageClassifier()
 
    func analyze(_ image: UIImage) async -> AnalysisResult {
        // 1. デバイス上で初期分類
        let onDeviceResult = onDeviceClassifier.classify(image)
 
        // 2. 信頼度に応じて処理を分岐
        if let confidence = onDeviceResult?.confidence, confidence > 0.8 {
            // 高信頼度 → デバイス内推論で結果を確定
            return AnalysisResult(
                category: onDeviceResult?.category ?? "Unknown",
                confidence: confidence,
                source: .onDevice
            )
        } else {
            // 低信頼度 → クラウド API に送信
            let cloudResult = await callCloudAnalysisAPI(image)
            return AnalysisResult(
                category: cloudResult.category,
                confidence: cloudResult.confidence,
                source: .cloud
            )
        }
    }
 
    private func callCloudAnalysisAPI(_ image: UIImage) async -> CloudAnalysisResult {
        // Google Vision API または Antigravity Cloud API
        // 実装詳細は省略
        return CloudAnalysisResult()
    }
}
 
struct AnalysisResult {
    let category: String
    let confidence: Float
    let source: AnalysisSource
 
    enum AnalysisSource {
        case onDevice
        case cloud
    }
}

pip install --upgrade coremltools

coreml_model = convert(..., compute_units=coremltools.ComputeUnit.CPU)

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