이제 실전으로 들어가볼까요? TensorFlow Lite 모델을 만드는 전체 과정을 단계별로 살펴볼게요. 걱정 마세요, 하나하나 친절하게 설명해드릴게요! 😊

Step 1: 기본 모델 학습하기

먼저 일반적인 TensorFlow로 모델을 학습시켜야 해요. 간단한 이미지 분류 모델을 예로 들어볼게요.

import tensorflow as tf
from tensorflow import keras
import numpy as np

# 데이터 준비 (예: MNIST 손글씨 숫자)
(train_images, train_labels), (test_images, test_labels) = keras.datasets.mnist.load_data()

# 데이터 전처리
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255

# 모델 구축
model = keras.Sequential([
    keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    keras.layers.MaxPooling2D((2, 2)),
    keras.layers.Conv2D(64, (3, 3), activation='relu'),
    keras.layers.MaxPooling2D((2, 2)),
    keras.layers.Flatten(),
    keras.layers.Dense(64, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

# 모델 컴파일 및 학습
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(train_images, train_labels, epochs=5, validation_split=0.2)

# 모델 저장
model.save('mnist_model.h5')

이 코드는 손글씨 숫자를 인식하는 CNN(Convolutional Neural Network) 모델을 만들어요. 실제로 돌려보면 98% 이상의 정확도를 보여줄 거예요! 🎯

Step 2: TensorFlow Lite로 변환하기

이제 학습된 모델을 모바일에서 사용할 수 있도록 변환해야 해요. 여기서 마법이 일어나죠! ✨

# 기본 변환
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

# 변환된 모델 저장
with open('mnist_model.tflite', 'wb') as f:
    f.write(tflite_model)

print(f"원본 모델 크기: {os.path.getsize('mnist_model.h5') / 1024:.2f} KB")
print(f"TFLite 모델 크기: {len(tflite_model) / 1024:.2f} KB")

Step 3: 양자화로 더 가볍게!

양자화(Quantization)는 모델을 더욱 압축하는 핵심 기술이에요. 32비트 부동소수점 숫자를 8비트 정수로 바꾸는 거죠. 정확도는 약간 떨어지지만, 크기와 속도 면에서 엄청난 이득을 봐요! 🚀

# 동적 범위 양자화 (가장 간단)
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quant_model = converter.convert()

with open('mnist_model_quant.tflite', 'wb') as f:
    f.write(tflite_quant_model)

# 전체 정수 양자화 (더 공격적)
def representative_dataset():
    for i in range(100):
        yield [train_images[i:i+1]]

converter = tf.lite.TFLiteConverter.from_keras_model(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_int8_model = converter.convert()

with open('mnist_model_int8.tflite', 'wb') as f:
    f.write(tflite_int8_model)

실제 프로젝트에서는 동적 범위 양자화부터 시작하는 걸 추천해요. 구현이 쉽고 정확도 손실도 거의 없거든요. 그다음에 성능이 더 필요하면 전체 정수 양자화를 시도해보세요!

자, 이제 변환된 모델을 실제 Android 앱에 통합해볼 시간이에요! Android Studio를 켜고 따라와 주세요. 🎮

Step 1: 프로젝트 설정

먼저 build.gradle 파일에 TensorFlow Lite 의존성을 추가해야 해요.

// app/build.gradle
android {
    aaptOptions {
        noCompress "tflite"  // TFLite 모델 압축 방지
    }
}

dependencies {
    // TensorFlow Lite
    implementation 'org.tensorflow:tensorflow-lite:2.13.0'
    
    // GPU 가속 지원 (선택사항)
    implementation 'org.tensorflow:tensorflow-lite-gpu:2.13.0'
    
    // Support Library (이미지 처리 등)
    implementation 'org.tensorflow:tensorflow-lite-support:0.4.4'
}

그리고 assets 폴더를 만들어서 .tflite 모델 파일을 넣어주세요. 프로젝트 구조는 이렇게 될 거예요:

📁 app
  📁 src
    📁 main
      📁 assets
        📄 mnist_model.tflite
      📁 java
      📁 res

Step 2: 모델 로드 및 추론 클래스 만들기

이제 실제로 모델을 사용하는 코드를 작성해볼게요. Kotlin으로 깔끔하게 만들어볼게요! 💎

import android.content.Context
import android.graphics.Bitmap
import org.tensorflow.lite.Interpreter
import org.tensorflow.lite.support.common.FileUtil
import org.tensorflow.lite.support.image.TensorImage
import org.tensorflow.lite.support.image.ops.ResizeOp
import java.nio.ByteBuffer

class DigitClassifier(private val context: Context) {
    private var interpreter: Interpreter? = null
    private val modelPath = "mnist_model.tflite"
    
    // 모델 초기화
    fun initialize() {
        val model = FileUtil.loadMappedFile(context, modelPath)
        
        // Interpreter 옵션 설정
        val options = Interpreter.Options().apply {
            // 스레드 개수 설정 (멀티코어 활용)
            setNumThreads(4)
            
            // GPU 가속 사용 (선택사항)
            // addDelegate(GpuDelegate())
        }
        
        interpreter = Interpreter(model, options)
    }
    
    // 이미지 분류
    fun classify(bitmap: Bitmap): Pair<Int, Float> {
        // 1. 이미지 전처리
        val tensorImage = TensorImage.fromBitmap(bitmap)
        val resizedImage = ResizeOp(28, 28, ResizeOp.ResizeMethod.BILINEAR)
            .apply(tensorImage)
        
        // 2. 입력 버퍼 준비
        val inputBuffer = resizedImage.buffer
        
        // 3. 출력 버퍼 준비
        val outputBuffer = Array(1) { FloatArray(10) }
        
        // 4. 추론 실행
        interpreter?.run(inputBuffer, outputBuffer)
        
        // 5. 결과 해석
        val probabilities = outputBuffer[0]
        val maxIndex = probabilities.indices.maxByOrNull { probabilities[it] } ?: -1
        val confidence = probabilities[maxIndex]
        
        return Pair(maxIndex, confidence)
    }
    
    // 리소스 정리
    fun close() {
        interpreter?.close()
        interpreter = null
    }
}

Step 3: Activity에서 사용하기

이제 실제 화면에서 사용해볼까요? 카메라로 찍은 사진이나 갤러리에서 선택한 이미지를 분류하는 간단한 예제예요.

class MainActivity : AppCompatActivity() {
    private lateinit var classifier: DigitClassifier
    private lateinit var imageView: ImageView
    private lateinit var resultText: TextView
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        imageView = findViewById(R.id.imageView)
        resultText = findViewById(R.id.resultText)
        
        // 분류기 초기화
        classifier = DigitClassifier(this)
        classifier.initialize()
        
        // 이미지 선택 버튼
        findViewById<Button>(R.id.selectButton).setOnClickListener {
            selectImage()
        }
    }
    
    private fun selectImage() {
        val intent = Intent(Intent.ACTION_PICK)
        intent.type = "image/*"
        startActivityForResult(intent, REQUEST_IMAGE)
    }
    
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        
        if (requestCode == REQUEST_IMAGE && resultCode == RESULT_OK) {
            data?.data?.let { uri ->
                val bitmap = MediaStore.Images.Media.getBitmap(contentResolver, uri)
                imageView.setImageBitmap(bitmap)
                
                // 분류 실행
                val startTime = System.currentTimeMillis()
                val (digit, confidence) = classifier.classify(bitmap)
                val inferenceTime = System.currentTimeMillis() - startTime
                
                // 결과 표시
                resultText.text = """
                    예측 숫자: $digit
                    신뢰도: ${(confidence * 100).toInt()}%
                    추론 시간: ${inferenceTime}ms
                """.trimIndent()
            }
        }
    }
    
    override fun onDestroy() {
        super.onDestroy()
        classifier.close()
    }
    
    companion object {
        private const val REQUEST_IMAGE = 100
    }
}

이렇게 하면 사용자가 이미지를 선택하면 즉시 AI가 분석해서 결과를 보여줘요. 실제로 돌려보면 추론 시간이 10-30ms 정도밖에 안 걸려요. 정말 빠르죠? ⚡

Android 개발자들은 이제 쉬어도 돼요! iOS 개발자 여러분, 이제 여러분 차례예요. 🎉

iOS에서도 TensorFlow Lite를 사용하는 방법은 Android와 크게 다르지 않아요. Swift로 깔끔하게 구현해볼게요!

Step 1: CocoaPods로 설치하기

먼저 Podfile에 TensorFlow Lite를 추가해주세요.

# Podfile
platform :ios, '12.0'

target 'YourApp' do
  use_frameworks!
  
  # TensorFlow Lite
  pod 'TensorFlowLiteSwift', '~> 2.13.0'
  
  # Metal 가속 지원 (선택사항)
  pod 'TensorFlowLiteSwift/Metal', '~> 2.13.0'
end

터미널에서 pod install을 실행하고, 생성된 .xcworkspace 파일을 열어주세요.

Step 2: 모델 추가 및 분류기 구현

모델 파일을 프로젝트에 드래그 앤 드롭으로 추가하고, Swift로 분류기를 만들어볼게요.

import UIKit
import TensorFlowLite

class DigitClassifier {
    private var interpreter: Interpreter?
    private let modelFileName = "mnist_model"
    
    // 모델 초기화
    func initialize() throws {
        guard let modelPath = Bundle.main.path(forResource: modelFileName, 
                                               ofType: "tflite") else {
            throw ClassifierError.modelNotFound
        }
        
        // Interpreter 옵션 설정
        var options = Interpreter.Options()
        options.threadCount = 4
        
        // Metal 가속 사용 (선택사항)
        // let delegate = MetalDelegate()
        // options.addDelegate(delegate)
        
        interpreter = try Interpreter(modelPath: modelPath, options: options)
        try interpreter?.allocateTensors()
    }
    
    // 이미지 분류
    func classify(image: UIImage) throws -> (digit: Int, confidence: Float) {
        guard let interpreter = interpreter else {
            throw ClassifierError.interpreterNotInitialized
        }
        
        // 1. 이미지 전처리
        guard let resizedImage = image.resize(to: CGSize(width: 28, height: 28)),
              let pixelBuffer = resizedImage.toGrayscaleBuffer() else {
            throw ClassifierError.imageProcessingFailed
        }
        
        // 2. 입력 데이터 복사
        try interpreter.copy(Data(bytes: pixelBuffer, count: 28 * 28), 
                            toInputAt: 0)
        
        // 3. 추론 실행
        try interpreter.invoke()
        
        // 4. 출력 데이터 가져오기
        let outputTensor = try interpreter.output(at: 0)
        let results = [Float32](unsafeData: outputTensor.data) ?? []
        
        // 5. 결과 해석
        guard let maxIndex = results.indices.max(by: { results[$0] < results[$1] }) else {
            throw ClassifierError.resultProcessingFailed
        }
        
        return (digit: maxIndex, confidence: results[maxIndex])
    }
    
    enum ClassifierError: Error {
        case modelNotFound
        case interpreterNotInitialized
        case imageProcessingFailed
        case resultProcessingFailed
    }
}

// UIImage 확장 - 전처리 헬퍼 함수
extension UIImage {
    func resize(to size: CGSize) -> UIImage? {
        UIGraphicsBeginImageContextWithOptions(size, false, 1.0)
        defer { UIGraphicsEndImageContext() }
        draw(in: CGRect(origin: .zero, size: size))
        return UIGraphicsGetImageFromCurrentImageContext()
    }
    
    func toGrayscaleBuffer() -> [UInt8]? {
        guard let cgImage = self.cgImage else { return nil }
        
        let width = cgImage.width
        let height = cgImage.height
        var buffer = [UInt8](repeating: 0, count: width * height)
        
        let colorSpace = CGColorSpaceCreateDeviceGray()
        let context = CGContext(data: &buffer,
                               width: width,
                               height: height,
                               bitsPerComponent: 8,
                               bytesPerRow: width,
                               space: colorSpace,
                               bitmapInfo: CGImageAlphaInfo.none.rawValue)
        
        context?.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
        
        return buffer
    }
}

// Array 확장 - 데이터 변환 헬퍼
extension Array {
    init?(unsafeData: Data) {
        guard unsafeData.count % MemoryLayout<Element>.stride == 0 else { return nil }
        self = unsafeData.withUnsafeBytes { .init($0.bindMemory(to: Element.self)) }
    }
}

Step 3: ViewController에서 사용하기

class ViewController: UIViewController, UIImagePickerControllerDelegate, 
                      UINavigationControllerDelegate {
    
    @IBOutlet weak var imageView: UIImageView!
    @IBOutlet weak var resultLabel: UILabel!
    
    private let classifier = DigitClassifier()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        do {
            try classifier.initialize()
        } catch {
            print("모델 초기화 실패: \(error)")
        }
    }
    
    @IBAction func selectImageTapped(_ sender: UIButton) {
        let picker = UIImagePickerController()
        picker.delegate = self
        picker.sourceType = .photoLibrary
        present(picker, animated: true)
    }
    
    func imagePickerController(_ picker: UIImagePickerController, 
                              didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
        picker.dismiss(animated: true)
        
        guard let image = info[.originalImage] as? UIImage else { return }
        imageView.image = image
        
        // 분류 실행
        let startTime = Date()
        do {
            let result = try classifier.classify(image: image)
            let inferenceTime = Date().timeIntervalSince(startTime) * 1000
            
            resultLabel.text = """
            예측 숫자: \(result.digit)
            신뢰도: \(Int(result.confidence * 100))%
            추론 시간: \(Int(inferenceTime))ms
            """
        } catch {
            resultLabel.text = "분류 실패: \(error)"
        }
    }
}

손글씨 인식은 시작에 불과해요! TensorFlow Lite로 구현할 수 있는 멋진 기능들을 소개할게요. 🌟

1. 이미지 분류 (Image Classification)

가장 기본적이면서도 강력한 기능이에요. 사진 속 물체가 무엇인지 알아내는 거죠.

// MobileNet 사용 예시 (Kotlin)
class ImageClassifier(context: Context) {
    private val labels = loadLabels(context, "labels.txt")
    
    fun classifyImage(bitmap: Bitmap): List<Classification> {
        // 전처리: 224x224로 리사이즈, 정규화
        val input = preprocessImage(bitmap, 224, 224)
        
        // 추론
        val output = Array(1) { FloatArray(1000) }
        interpreter.run(input, output)
        
        // Top-5 결과 반환
        return output[0]
            .mapIndexed { index, score -> Classification(labels[index], score) }
            .sortedByDescending { it.score }
            .take(5)
    }
}

data class Classification(val label: String, val score: Float)

2. 객체 탐지 (Object Detection)

이미지 분류보다 한 단계 더 나아가서, 사진 속 여러 물체의 위치까지 찾아내요! 📍

// 객체 탐지 결과 처리
data class Detection(
    val boundingBox: RectF,
    val label: String,
    val score: Float
)

fun detectObjects(bitmap: Bitmap): List<Detection> {
    val detections = mutableListOf<Detection>()
    
    // 모델 출력: [위치, 클래스, 점수, 개수]
    val locations = Array(1) { Array(10) { FloatArray(4) } }
    val classes = Array(1) { FloatArray(10) }
    val scores = Array(1) { FloatArray(10) }
    val numDetections = FloatArray(1)
    
    val outputs = mapOf(
        0 to locations,
        1 to classes,
        2 to scores,
        3 to numDetections
    )
    
    interpreter.runForMultipleInputsOutputs(arrayOf(inputBuffer), outputs)
    
    val count = numDetections[0].toInt()
    for (i in 0 until count) {
        if (scores[0][i] > 0.5f) {  // 신뢰도 50% 이상만
            val box = RectF(
                locations[0][i][1] * bitmap.width,
                locations[0][i][0] * bitmap.height,
                locations[0][i][3] * bitmap.width,
                locations[0][i][2] * bitmap.height
            )
            detections.add(Detection(box, labels[classes[0][i].toInt()], scores[0][i]))
        }
    }
    
    return detections
}

3. 포즈 추정 (Pose Estimation)

사람의 자세와 동작을 실시간으로 분석해요. 피트니스 앱이나 AR 게임에 완벽하죠! 🏃‍♂️

// 포즈 추정 결과
data class Keypoint(
    val bodyPart: BodyPart,
    val position: PointF,
    val score: Float
)

enum class BodyPart {
    NOSE, LEFT_EYE, RIGHT_EYE, LEFT_EAR, RIGHT_EAR,
    LEFT_SHOULDER, RIGHT_SHOULDER, LEFT_ELBOW, RIGHT_ELBOW,
    LEFT_WRIST, RIGHT_WRIST, LEFT_HIP, RIGHT_HIP,
    LEFT_KNEE, RIGHT_KNEE, LEFT_ANKLE, RIGHT_ANKLE
}

class PoseDetector(context: Context) {
    fun estimatePose(bitmap: Bitmap): List<Keypoint> {
        // 입력: 192x192 이미지
        val input = preprocessImage(bitmap, 192, 192)
        
        // 출력: [1, 17, 3] (17개 관절, 각각 y, x, confidence)
        val output = Array(1) { Array(17) { FloatArray(3) } }
        interpreter.run(input, output)
        
        return output[0].mapIndexed { index, data ->
            Keypoint(
                bodyPart = BodyPart.values()[index],
                position = PointF(
                    data[1] * bitmap.width,
                    data[0] * bitmap.height
                ),
                score = data[2]
            )
        }.filter { it.score > 0.3f }
    }
    
    // 스쿼트 자세 분석 예시
    fun analyzeSquat(keypoints: List<Keypoint>): String {
        val leftKnee = keypoints.find { it.bodyPart == BodyPart.LEFT_KNEE }
        val leftHip = keypoints.find { it.bodyPart == BodyPart.LEFT_HIP }
        val leftAnkle = keypoints.find { it.bodyPart == BodyPart.LEFT_ANKLE }
        
        if (leftKnee != null && leftHip != null && leftAnkle != null) {
            val angle = calculateAngle(leftHip.position, leftKnee.position, leftAnkle.position)
            return when {
                angle < 90 -> "더 깊게 앉으세요!"
                angle > 120 -> "무릎을 더 구부리세요!"
                else -> "완벽한 자세입니다! 👍"
            }
        }
        return "자세를 인식할 수 없습니다"
    }
}

4. 텍스트 인식 (OCR)

이미지 속 텍스트를 읽어내는 기능이에요. 명함, 문서, 간판 등을 스캔할 때 유용하죠! 📝

5. 음성 인식 (Speech Recognition)

음성을 텍스트로 변환하거나, 특정 명령어를 인식할 수 있어요. 🎤

6. 스타일 전이 (Style Transfer)

사진을 예술 작품처럼 변환해주는 재미있는 기능이에요! 🎨

모델을 만들고 통합하는 것도 중요하지만, 실제 사용자 경험을 위해서는 성능 최적화가 필수예요! 여기 검증된 최적화 기법들을 소개할게요. 🚀

1. 하드웨어 가속 활용하기

현대 스마트폰에는 AI 연산을 위한 특수 하드웨어가 탑재되어 있어요. 이걸 제대로 활용하면 속도가 몇 배나 빨라져요!

// NNAPI 사용 (Android 8.1+)
val options = Interpreter.Options()
val nnApiDelegate = NnApiDelegate()
options.addDelegate(nnApiDelegate)

val interpreter = Interpreter(modelFile, options)

// GPU 가속 사용
val options = Interpreter.Options()
val gpuDelegate = GpuDelegate()
options.addDelegate(gpuDelegate)

val interpreter = Interpreter(modelFile, options)

// 사용 후 정리
gpuDelegate.close()

// Core ML 가속 사용
var options = Interpreter.Options()
let coreMLDelegate = CoreMLDelegate()
options.addDelegate(coreMLDelegate)

let interpreter = try Interpreter(modelPath: modelPath, options: options)

2. 모델 최적화 기법

모델 자체를 최적화하면 모든 기기에서 성능이 향상돼요!

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]
tflite_model = converter.convert()

def representative_dataset():
    for data in train_dataset.take(100):
        yield [data]

converter = tf.lite.TFLiteConverter.from_keras_model(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()

3. 입력 데이터 최적화

모델에 들어가는 데이터를 효율적으로 처리하는 것도 중요해요!

// 효율적인 이미지 전처리 (Kotlin)
class ImagePreprocessor {
    // ❌ 비효율적인 방법
    fun preprocessSlow(bitmap: Bitmap): ByteBuffer {
        val resized = Bitmap.createScaledBitmap(bitmap, 224, 224, true)
        val buffer = ByteBuffer.allocateDirect(224 * 224 * 3 * 4)
        buffer.order(ByteOrder.nativeOrder())
        
        for (y in 0 until 224) {
            for (x in 0 until 224) {
                val pixel = resized.getPixel(x, y)
                buffer.putFloat(((pixel shr 16) and 0xFF) / 255.0f)
                buffer.putFloat(((pixel shr 8) and 0xFF) / 255.0f)
                buffer.putFloat((pixel and 0xFF) / 255.0f)
            }
        }
        return buffer
    }
    
    // ✅ 효율적인 방법
    fun preprocessFast(bitmap: Bitmap): ByteBuffer {
        val resized = Bitmap.createScaledBitmap(bitmap, 224, 224, true)
        val buffer = ByteBuffer.allocateDirect(224 * 224 * 3 * 4)
        buffer.order(ByteOrder.nativeOrder())
        
        val intValues = IntArray(224 * 224)
        resized.getPixels(intValues, 0, 224, 0, 0, 224, 224)
        
        var pixel = 0
        for (i in 0 until 224) {
            for (j in 0 until 224) {
                val value = intValues[pixel++]
                buffer.putFloat(((value shr 16) and 0xFF) / 255.0f)
                buffer.putFloat(((value shr 8) and 0xFF) / 255.0f)
                buffer.putFloat((value and 0xFF) / 255.0f)
            }
        }
        buffer.rewind()
        return buffer
    }
}

4. 배치 처리와 비동기 실행

여러 이미지를 처리해야 한다면 배치로 묶어서 처리하고, UI 스레드를 블록하지 않도록 비동기로 실행하세요!

// Kotlin Coroutines를 활용한 비동기 추론
class AsyncClassifier(context: Context) {
    private val classifier = ImageClassifier(context)
    private val scope = CoroutineScope(Dispatchers.Default)
    
    fun classifyAsync(bitmap: Bitmap, callback: (Result) -> Unit) {
        scope.launch {
            try {
                val result = classifier.classify(bitmap)
                withContext(Dispatchers.Main) {
                    callback(Result.Success(result))
                }
            } catch (e: Exception) {
                withContext(Dispatchers.Main) {
                    callback(Result.Error(e))
                }
            }
        }
    }
    
    // 배치 처리
    fun classifyBatch(bitmaps: List<Bitmap>): List<Classification> {
        val batchSize = bitmaps.size
        val inputBuffer = ByteBuffer.allocateDirect(batchSize * 224 * 224 * 3 * 4)
        
        // 모든 이미지를 하나의 버퍼에 담기
        bitmaps.forEach { bitmap ->
            val processed = preprocessImage(bitmap)
            inputBuffer.put(processed)
        }
        
        // 한 번에 추론
        val outputBuffer = Array(batchSize) { FloatArray(1000) }
        interpreter.run(inputBuffer, outputBuffer)
        
        return outputBuffer.map { scores ->
            scores.indices.maxByOrNull { scores[it] }?.let { index ->
                Classification(labels[index], scores[index])
            } ?: Classification("Unknown", 0f)
        }
    }
}

sealed class Result {
    data class Success(val classification: Classification) : Result()
    data class Error(val exception: Exception) : Result()
}

5. 메모리 관리

모바일 기기는 메모리가 제한적이에요. 효율적인 메모리 관리가 필수죠!

// 메모리 효율적인 분류기
class MemoryEfficientClassifier(context: Context) : AutoCloseable {
    private val interpreter: Interpreter
    private val gpuDelegate: GpuDelegate?
    private val inputBuffer: ByteBuffer
    private val outputBuffer: Array<FloatArray>
    
    init {
        // GPU Delegate 초기화
        gpuDelegate = try {
            GpuDelegate()
        } catch (e: Exception) {
            null  // GPU 미지원 기기
        }
        
        // Interpreter 초기화
        val options = Interpreter.Options().apply {
            gpuDelegate?.let { addDelegate(it) }
            setNumThreads(4)
        }
        interpreter = Interpreter(loadModelFile(context), options)
        
        // 버퍼 미리 할당 (재사용)
        inputBuffer = ByteBuffer.allocateDirect(224 * 224 * 3 * 4)
        inputBuffer.order(ByteOrder.nativeOrder())
        outputBuffer = Array(1) { FloatArray(1000) }
    }
    
    fun classify(bitmap: Bitmap): Classification {
        // 버퍼 재사용
        inputBuffer.rewind()
        fillInputBuffer(bitmap, inputBuffer)
        
        // 추론
        interpreter.run(inputBuffer, outputBuffer)
        
        // 결과 처리
        val scores = outputBuffer[0]
        val maxIndex = scores.indices.maxByOrNull { scores[it] } ?: 0
        return Classification(labels[maxIndex], scores[maxIndex])
    }
    
    override fun close() {
        interpreter.close()
        gpuDelegate?.close()
    }
}

// Activity에서 사용
class MainActivity : AppCompatActivity() {
    private lateinit var classifier: MemoryEfficientClassifier
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        classifier = MemoryEfficientClassifier(this)
    }
    
    override fun onDestroy() {
        super.onDestroy()
        classifier.close()  // 리소스 정리
    }
}