6장: 모바일 디바이스에서의 AI 추론

import CoreML
import NaturalLanguage
 
class OnDeviceLLM {
    private var model: MLModel?
    
    func loadModel() async throws {
        let config = MLModelConfiguration()
        config.computeUnits = .all  // ANE + GPU + CPU 자동 선택
        
        // 컴파일된 Core ML 모델 로딩
        let modelURL = Bundle.main.url(
            forResource: "Phi3Mini4K",
            withExtension: "mlmodelc"
        )!
        
        self.model = try await MLModel.load(
            contentsOf: modelURL,
            configuration: config
        )
    }
    
    func generate(prompt: String, maxTokens: Int = 256) async throws -> String {
        guard let model = self.model else {
            throw LLMError.modelNotLoaded
        }
        
        var tokens = tokenize(prompt)
        var output = ""
        
        for _ in 0..<maxTokens {
            let input = try MLDictionaryFeatureProvider(
                dictionary: ["input_ids": MLMultiArray(tokens)]
            )
            let prediction = try await model.prediction(from: input)
            let nextToken = argmax(prediction.featureValue(for: "logits")!)
            
            if nextToken == eosTokenId { break }
            tokens.append(nextToken)
            output += decode(nextToken)
        }
        
        return output
    }
}

import coremltools as ct
from transformers import AutoModelForCausalLM
 
model = AutoModelForCausalLM.from_pretrained("microsoft/Phi-3-mini-4k-instruct")
 
# Core ML 변환 (4비트 양자화 적용)
mlmodel = ct.convert(
    model,
    convert_to="mlprogram",
    minimum_deployment_target=ct.target.iOS18,
    compute_precision=ct.precision.FLOAT16,
)
 
# 양자화 적용
op_config = ct.optimize.coreml.OpLinearQuantizerConfig(
    mode="linear_symmetric",
    dtype="int4",
    granularity="per_block",
    block_size=32,
)
config = ct.optimize.coreml.OptimizationConfig(global_config=op_config)
mlmodel_quantized = ct.optimize.coreml.linear_quantize_weights(mlmodel, config)
 
mlmodel_quantized.save("Phi3Mini4K.mlpackage")

import mlx.core as mx
from mlx_lm import load, generate
 
# 4비트 양자화된 모델 로딩
model, tokenizer = load("mlx-community/Llama-3.1-8B-Instruct-4bit")
 
# 텍스트 생성
response = generate(
    model,
    tokenizer,
    prompt="모바일 AI의 미래에 대해 설명해주세요.",
    max_tokens=512,
    temp=0.7,
)
print(response)

# iOS용 llama.cpp 빌드 (Metal 지원)
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
 
mkdir build-ios && cd build-ios
cmake .. \
  -G Xcode \
  -DCMAKE_SYSTEM_NAME=iOS \
  -DCMAKE_OSX_DEPLOYMENT_TARGET=17.0 \
  -DLLAMA_METAL=ON \
  -DLLAMA_METAL_EMBED_LIBRARY=ON \
  -DBUILD_SHARED_LIBS=OFF

class LlamaCppWrapper {
    // JNI를 통한 llama.cpp 연동
    external fun loadModel(modelPath: String, nGpuLayers: Int): Long
    external fun generate(contextPtr: Long, prompt: String, maxTokens: Int): String
    external fun freeModel(contextPtr: Long)
    
    companion object {
        init {
            System.loadLibrary("llama-android")
        }
    }
    
    fun runInference(modelPath: String, prompt: String): String {
        // Vulkan GPU 가속 레이어 수 설정
        val ctx = loadModel(modelPath, nGpuLayers = 99)
        val result = generate(ctx, prompt, maxTokens = 256)
        freeModel(ctx)
        return result
    }
}

import com.google.mediapipe.tasks.genai.llminference.LlmInference
 
class MediaPipeLLMService(private val context: Context) {
    private var llmInference: LlmInference? = null
    
    fun initialize() {
        val options = LlmInference.LlmInferenceOptions.builder()
            .setModelPath("/data/local/tmp/gemma-2b-it-gpu-int4.bin")
            .setMaxTokens(1024)
            .setTemperature(0.7f)
            .setTopK(40)
            .setResultListener { partialResult, done ->
                // 스트리밍 결과 처리
                onTokenGenerated(partialResult, done)
            }
            .build()
        
        llmInference = LlmInference.createFromOptions(context, options)
    }
    
    fun generateResponse(prompt: String) {
        llmInference?.generateResponseAsync(prompt)
    }
}