IA On-Device en Móviles: CoreML, ML Kit y ONNX en 2026

La inteligencia artificial on-device ha pasado de ser un concepto futurista a una realidad presente en millones de dispositivos móviles. En 2026, implementar modelos de ML directamente en smartphones ya no es solo posible, sino necesario para muchas aplicaciones.

¿Por Qué IA On-Device?

Después de implementar sistemas de IA tanto en el servidor como on-device, las ventajas del procesamiento local son claras:

Privacidad Real

Los datos nunca salen del dispositivo. No hay “confianza” en terceros: la privacidad está garantizada por diseño.

Latencia Ultra-Baja

No hay roundtrips de red. La respuesta es instantánea, lo cual es crucial para aplicaciones en tiempo real.

Funcionamiento Offline

Tu aplicación funciona sin conexión, ampliando significativamente los casos de uso.

Costos Reducidos

No hay costos de servidor por inferencia. Una vez desplegado, el modelo funciona “gratis”.

El Estado de las Plataformas en 2026

CoreML: La Propuesta de Apple

Apple ha duplicado su inversión en CoreML. La plataforma ha madurado considerablemente:

import CoreML

// Cargar modelo optimizado
guard let model = try? VNCoreMLModel(for: MyImageClassifier().model) else {
    return
}

// Configurar la petición
let request = VNCoreMLRequest(model: model) { request, error in
    guard let results = request.results as? [VNClassificationObservation] else {
        return
    }
    
    // Procesar resultados
    let topResult = results.first
    print("Predicción: \(topResult?.identifier ?? "")")
    print("Confianza: \(topResult?.confidence ?? 0)")
}

// Ejecutar inferencia
let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer)
try? handler.perform([request])

Ventajas de CoreML:

• Optimización automática para hardware Apple (Neural Engine, GPU, CPU)
• Integración perfecta con Vision framework
• Herramientas de conversión desde TensorFlow, PyTorch, etc.
• Quantización automática y optimización de modelos

Limitaciones:

• Exclusivo para ecosistema Apple
• Menos control sobre la optimización manual
• Formato propietario (.mlmodel)

ML Kit: La Solución de Google

Google ha expandido ML Kit significativamente, ofreciendo APIs de alto nivel y soporte para modelos custom:

// APIs predefinidas
val options = FaceDetectorOptions.Builder()
    .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
    .setContourMode(FaceDetectorOptions.CONTOUR_MODE_ALL)
    .build()

val detector = FaceDetection.getClient(options)

// Modelos custom
val localModel = CustomLocalModel.Builder()
    .setAssetFilePath("model.tflite")
    .build()

val customObjectDetectorOptions = CustomObjectDetectorOptions.Builder(localModel)
    .enableClassification()
    .enableMultipleObjects()
    .build()

val objectDetector = ObjectDetection.getClient(customObjectDetectorOptions)

Ventajas de ML Kit:

• APIs predefinidas para casos comunes (OCR, detección facial, etc.)
• Soporte para TensorFlow Lite nativo
• Funciona en Android y iOS
• Fallback automático a la nube cuando sea necesario

ONNX Runtime: El Estándar Abierto

ONNX Runtime ha ganado tracción como solución multiplataforma:

// Android con ONNX Runtime
val session = OrtEnvironment.getEnvironment()
    .createInferenceSession("model.onnx")

val inputTensor = OnnxTensor.createTensorFromBuffer(
    OrtEnvironment.getEnvironment(),
    inputBuffer,
    longArrayOf(1, 3, 224, 224)
)

val results = session.run(mapOf("input" to inputTensor))
val output = results[0].value as Array<FloatArray>

// iOS con ONNX Runtime
import onnxruntime_objc

let session = try ORTSession(env: ortEnv, modelPath: modelPath)

let inputTensor = try ORTValue(
    tensorData: NSMutableData(data: inputData),
    elementType: .float,
    shape: [1, 3, 224, 224]
)

let outputs = try session.run(
    withInputs: ["input": inputTensor],
    outputNames: ["output"]
)

Ventajas de ONNX:

• Verdaderamente multiplataforma
• Estándar abierto e interoperable
• Soporte para múltiples frameworks (PyTorch, TensorFlow, etc.)
• Control granular sobre la optimización

Casos de Uso Reales: Lecciones Aprendidas

1. Análisis de Documentos en Tiempo Real

Para la aplicación Leonard AI, implementamos OCR on-device para facturas médicas:

Desafío: Procesar documentos de forma privada y rápida.

Solución:

• iOS: CoreML + Vision para detección de texto
• Android: ML Kit Text Recognition v2

Resultado: 95% de precisión, procesamiento en menos de 200ms.

// Implementación iOS
func recognizeText(in image: UIImage) {
    guard let cgImage = image.cgImage else { return }
    
    let request = VNRecognizeTextRequest { request, error in
        guard let observations = request.results as? [VNRecognizedTextObservation] else {
            return
        }
        
        let recognizedStrings = observations.compactMap { observation in
            observation.topCandidates(1).first?.string
        }
        
        // Procesar texto reconocido
        self.processRecognizedText(recognizedStrings)
    }
    
    request.recognitionLevel = .accurate
    request.recognitionLanguages = ["es-ES", "en-US"]
    
    let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
    try? handler.perform([request])
}

2. Clasificación de Imágenes de Salud

En Kunoa, clasificamos alimentos para análisis nutricional:

Modelo: MobileNetV3 optimizado (2.1MB) Precisión: 89% en top-3 predictions Latencia: menos de 50ms en dispositivos modernos

// Implementación Android con TensorFlow Lite
class FoodClassifier(context: Context) {
    private val interpreter: Interpreter
    
    init {
        val assetManager = context.assets
        val model = loadModelFile(assetManager, "food_classifier.tflite")
        interpreter = Interpreter(model)
    }
    
    fun classify(bitmap: Bitmap): List<Prediction> {
        val input = preprocessImage(bitmap)
        val output = Array(1) { FloatArray(NUM_CLASSES) }
        
        interpreter.run(input, output)
        
        return output[0]
            .mapIndexed { index, confidence -> 
                Prediction(labels[index], confidence) 
            }
            .sortedByDescending { it.confidence }
            .take(3)
    }
    
    private fun preprocessImage(bitmap: Bitmap): ByteBuffer {
        val resizedBitmap = Bitmap.createScaledBitmap(bitmap, 224, 224, true)
        val buffer = ByteBuffer.allocateDirect(4 * 224 * 224 * 3)
        buffer.order(ByteOrder.nativeOrder())
        
        val pixels = IntArray(224 * 224)
        resizedBitmap.getPixels(pixels, 0, 224, 0, 0, 224, 224)
        
        for (pixel in pixels) {
            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
    }
}

Optimización: El Factor Crítico

Quantización

La quantización de modelos es esencial para dispositivos móviles:

# Quantización post-entrenamiento con TensorFlow Lite
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]

# Quantización más agresiva
converter.target_spec.supported_types = [tf.float16]

# Para máxima compresión (con pérdida mínima de precisión)
converter.representative_dataset = representative_data_gen
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]

tflite_quantized_model = converter.convert()

Gestión de Memoria

Crítico para evitar OOM crashes:

// iOS: Gestión de memoria en CoreML
class ModelManager {
    private var model: MLModel?
    
    func loadModelWhenNeeded() {
        guard model == nil else { return }
        
        do {
            model = try MyImageClassifier(configuration: .init())
        } catch {
            print("Error loading model: \(error)")
        }
    }
    
    func unloadModelIfNeeded() {
        // Liberar modelo cuando no se necesite
        if memoryPressure() {
            model = nil
        }
    }
}

Paralelización

Usar múltiples hilos cuando sea apropiado:

// Android: Ejecutar inferencia en background
class ModelInferenceManager {
    private val inferenceExecutor = Executors.newSingleThreadExecutor()
    
    fun runInference(
        input: ByteBuffer,
        callback: (Result<FloatArray>) -> Unit
    ) {
        inferenceExecutor.execute {
            try {
                val output = interpreter.runInference(input)
                callback(Result.success(output))
            } catch (e: Exception) {
                callback(Result.failure(e))
            }
        }
    }
}

Comparativa de Performance

Basándome en benchmarks reales en dispositivos de 2025-2026:

MobileNetV3 (224x224)

• CoreML (iPhone 15 Pro): 8ms promedio
• TensorFlow Lite (Pixel 8): 12ms promedio
• ONNX Runtime: 15-25ms dependiendo del dispositivo

BERT Base (NLP)

• CoreML: 45ms para secuencias de 128 tokens
• TensorFlow Lite: 60ms promedio
• ONNX Runtime: 70-90ms

Mejores Prácticas

1. Selección de Framework

• CoreML: Si solo desarrollas para iOS y quieres máxima optimización
• ML Kit: Para casos de uso comunes y APIs predefinidas
• ONNX Runtime: Para máxima portabilidad y control

2. Optimización del Modelo

• Usa quantización siempre que sea posible
• Prueba pruning para reducir el tamaño
• Considera knowledge distillation para modelos complejos

3. UX Considerations

• Muestra loading states durante la primera carga del modelo
• Implementa fallbacks para dispositivos de bajo rendimiento
• Considera modelos híbridos (on-device + cloud)

El Futuro: NPUs y Hardware Especializado

Los Neural Processing Units (NPUs) están cambiando el juego:

• Apple Neural Engine: 4ta generación en A17 Pro
• Google Tensor G4: TPU optimizada para Pixel
• Qualcomm Hexagon: NPU en Snapdragon 8 Gen 3

Estos chips especializados ofrecen:

• 10-100x mejor eficiencia energética
• Latencias sub-milisegundo para modelos optimizados
• Soporte para modelos más grandes on-device

Conclusión

La IA on-device ya no es el futuro: es el presente. En 2026, los usuarios esperan que las aplicaciones funcionen instantáneamente, offline, y respetando su privacidad.

Recomendaciones para desarrolladores:

1. Empieza simple: Usa APIs predefinidas (ML Kit) antes de crear modelos custom
2. Optimiza desde el inicio: La performance on-device requiere optimización desde el diseño del modelo
3. Testea en dispositivos reales: Los emuladores no reflejan la performance real
4. Considera el hardware: Optimiza para los NPUs disponibles

La IA on-device está democratizando el machine learning móvil. Es momento de aprovechar esta oportunidad.

---

¿Has implementado IA on-device en tus aplicaciones? ¿Qué framework prefieres y por qué? Comparte tu experiencia.