Edge AI × Antigravity — Core ML / TensorFlow Lite でオンデバイスAI推論アプリを開発する実践ガイド

# convert_to_coreml.py
# PyTorch の画像分類モデルを Core ML 形式に変換するスクリプト
import torch
import coremltools as ct
from torchvision.models import mobilenet_v3_small, MobileNet_V3_Small_Weights
 
# 学習済みモデルをロード
weights = MobileNet_V3_Small_Weights.DEFAULT
model = mobilenet_v3_small(weights=weights)
model.eval()
 
# トレース用のダミー入力
dummy_input = torch.randn(1, 3, 224, 224)
traced_model = torch.jit.trace(model, dummy_input)
 
# Core ML 形式に変換（量子化オプション付き）
mlmodel = ct.convert(
    traced_model,
    inputs=[ct.ImageType(name="image", shape=(1, 3, 224, 224))],
    convert_to="mlprogram",  # ML Program 形式（iOS 15+）
    compute_precision=ct.precision.FLOAT16,  # FP16量子化でサイズ半減
)
 
# 期待する出力:
# メタデータ付きの .mlpackage ファイルが生成される
mlmodel.save("ImageClassifier.mlpackage")
print("✅ Core ML モデルの変換が完了しました")
print(f"   モデルサイズ: 約 {mlmodel.__sizeof__() / 1024 / 1024:.1f} MB")

// ImageClassifierService.swift
// Core ML モデルでリアルタイム画像分類を実行するサービス
import CoreML
import Vision
 
class ImageClassifierService {
    private let model: VNCoreMLModel
 
    init() throws {
        // Core ML モデルをロード
        let config = MLModelConfiguration()
        config.computeUnits = .all  // Neural Engine + GPU + CPU を自動選択
        let mlModel = try ImageClassifier(configuration: config).model
        self.model = try VNCoreMLModel(for: mlModel)
    }
 
    func classify(image: CGImage) async throws -> [(label: String, confidence: Float)] {
        return try await withCheckedThrowingContinuation { continuation in
            let request = VNCoreMLRequest(model: model) { request, error in
                if let error = error {
                    continuation.resume(throwing: error)
                    return
                }
                guard let results = request.results as? [VNClassificationObservation] else {
                    continuation.resume(returning: [])
                    return
                }
                // 上位5件の分類結果を返す
                let topResults = results.prefix(5).map {
                    (label: $0.identifier, confidence: $0.confidence)
                }
                continuation.resume(returning: topResults)
            }
            // Neural Engine を優先的に使用
            request.usesCPUOnly = false
 
            let handler = VNImageRequestHandler(cgImage: image)
            try? handler.perform([request])
        }
    }
}
 
// 期待する出力例:
// [("golden_retriever", 0.92), ("labrador", 0.05), ("dog", 0.02), ...]

# quantize_tflite.py
# TensorFlow モデルを INT8 量子化した TFLite 形式に変換
import tensorflow as tf
import numpy as np
 
# 代表データセットのジェネレータ（量子化キャリブレーション用）
def representative_dataset():
    """量子化の精度を維持するための代表データを提供"""
    for _ in range(100):
        # 実際のユースケースに近い入力データを用意する
        data = np.random.rand(1, 224, 224, 3).astype(np.float32)
        yield [data]
 
# SavedModel を TFLite に変換
converter = tf.lite.TFLiteConverter.from_saved_model("saved_model/")
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8
 
tflite_model = converter.convert()
 
# 量子化モデルを保存
with open("model_quantized.tflite", "wb") as f:
    f.write(tflite_model)
 
# 期待する出力:
# ファイルサイズが元のモデルの約25%に削減される
# 例: 16MB → 4MB（INT8量子化適用後）
original_size = 16.0  # MB（例）
quantized_size = len(tflite_model) / 1024 / 1024
print(f"✅ 量子化完了")
print(f"   元のサイズ: {original_size:.1f} MB")
print(f"   量子化後: {quantized_size:.1f} MB")
print(f"   削減率: {(1 - quantized_size / original_size) * 100:.0f}%")

// EdgeAIClassifier.kt
// TensorFlow Lite を使った Android 向け画像分類
import android.content.Context
import android.graphics.Bitmap
import org.tensorflow.lite.Interpreter
import org.tensorflow.lite.gpu.GpuDelegate
import java.io.FileInputStream
import java.nio.ByteBuffer
import java.nio.ByteOrder
import java.nio.MappedByteBuffer
import java.nio.channels.FileChannel
 
class EdgeAIClassifier(private val context: Context) {
 
    private var interpreter: Interpreter? = null
    private var gpuDelegate: GpuDelegate? = null
 
    fun initialize() {
        // GPU デリゲートでハードウェアアクセラレーション
        gpuDelegate = GpuDelegate()
        val options = Interpreter.Options().apply {
            addDelegate(gpuDelegate!!)
            setNumThreads(4) // GPU が使えない場合のフォールバック
        }
        val modelBuffer = loadModelFile("model_quantized.tflite")
        interpreter = Interpreter(modelBuffer, options)
    }
 
    fun classify(bitmap: Bitmap): List<Pair<String, Float>> {
        val inputBuffer = preprocessImage(bitmap)
        val outputBuffer = Array(1) { FloatArray(1000) }
 
        interpreter?.run(inputBuffer, outputBuffer)
 
        // 上位5件の結果をラベルとスコアのペアで返す
        return outputBuffer[0]
            .mapIndexed { index, score -> Pair(labels[index], score) }
            .sortedByDescending { it.second }
            .take(5)
    }
 
    // 期待する出力例:
    // [("golden_retriever", 0.91), ("labrador", 0.04), ...]
 
    private fun preprocessImage(bitmap: Bitmap): ByteBuffer {
        val buffer = ByteBuffer.allocateDirect(1 * 224 * 224 * 3)
        buffer.order(ByteOrder.nativeOrder())
        val resized = Bitmap.createScaledBitmap(bitmap, 224, 224, true)
        val pixels = IntArray(224 * 224)
        resized.getPixels(pixels, 0, 224, 0, 0, 224, 224)
        for (pixel in pixels) {
            buffer.put(((pixel shr 16) and 0xFF).toByte()) // R
            buffer.put(((pixel shr 8) and 0xFF).toByte())  // G
            buffer.put((pixel and 0xFF).toByte())            // B
        }
        return buffer
    }
 
    private fun loadModelFile(filename: String): MappedByteBuffer {
        val fd = context.assets.openFd(filename)
        val input = FileInputStream(fd.fileDescriptor)
        val channel = input.channel
        return channel.map(FileChannel.MapMode.READ_ONLY, fd.startOffset, fd.declaredLength)
    }
 
    fun release() {
        interpreter?.close()
        gpuDelegate?.close()
    }
 
    companion object {
        private val labels = listOf(/* ImageNet ラベル 1000件 */)
    }
}

<!-- AGENTS.md -->
# Edge AI モバイルアプリプロジェクト
 
## コンテキスト
- iOS: Swift + Core ML（iOS 17+対象）
- Android: Kotlin + TensorFlow Lite（API 26+対象）
- モデル: MobileNetV3 ベースの画像分類
 
## コーディング規約
- エラーハンドリングを省略しないこと
- メモリリークを防ぐため、モデルの解放処理を必ず実装すること
- パフォーマンス計測のログを推論コードに含めること

// ImageClassifierTests.swift
// 推論精度とレイテンシのベンチマークテスト
import XCTest
@testable import MyApp
 
class ImageClassifierTests: XCTestCase {
    var classifier: ImageClassifierService!
 
    override func setUpWithError() throws {
        classifier = try ImageClassifierService()
    }
 
    func testClassificationAccuracy() async throws {
        let testImage = loadTestImage("golden_retriever.jpg")
        let results = try await classifier.classify(image: testImage)
 
        XCTAssertFalse(results.isEmpty, "分類結果が空です")
        XCTAssertEqual(results[0].label, "golden_retriever")
        XCTAssertGreaterThan(results[0].confidence, 0.8)
    }
 
    func testInferenceLatency() async throws {
        let testImage = loadTestImage("sample.jpg")
 
        // 10回実行して平均レイテンシを計測
        let start = CFAbsoluteTimeGetCurrent()
        for _ in 0..<10 {
            _ = try await classifier.classify(image: testImage)
        }
        let elapsed = (CFAbsoluteTimeGetCurrent() - start) / 10
 
        // Neural Engine 使用時は 20ms 以下を期待
        print("平均推論時間: \(elapsed * 1000)ms")
        XCTAssertLessThan(elapsed, 0.1, "推論時間が100msを超えています")
    }
 
    // 期待する出力:
    // 平均推論時間: 12.3ms（iPhone 15 Pro, Neural Engine使用時）
}