Conversión de Modelos Core ML: qué es, etapas y métodos de conversión

Qué es Core ML Model Conversion

Core ML Model Conversion es el proceso de transformar un modelo de machine learning entrenado desde el formato del framework de origen al formato .mlmodel que entiende Core ML Runtime en dispositivos Apple. Sin conversión, un modelo entrenado en PyTorch o TensorFlow no puede cargarse ni ejecutarse directamente en iOS o macOS.

El proceso de conversión incluye la traducción del grafo de cálculo: cada operador del framework de origen (Conv2D, BatchNorm, ReLU) se asigna al operador Core ML correspondiente. Si no existe un reemplazo directo, coremltools utiliza operaciones compuestas o capas personalizadas. Según Apple ML Research, la biblioteca cubre más de 200 operadores de diversos frameworks.

Después de la conversión, el modelo se guarda en el formato de paquete .mlmodel, que incluye una descripción del grafo en protobuf, pesos en forma binaria y metadatos. Este archivo luego se compila en mlmodelc para su ejecución en el dispositivo de destino.

Frameworks y Formatos Soportados

coremltools versión 7.x admite la conversión desde seis fuentes. PyTorch — mediante torch.jit.trace o torch.export, TensorFlow 2.x — mediante SavedModel y Keras H5, TensorFlow 1.x — mediante grafo congelado .pb. Para ONNX se utiliza una representación intermedia que luego se traduce a Core ML.

Matriz de Compatibilidad de Frameworks

Herramientas de Conversión: coremltools

coremltools es la biblioteca Python oficial de código abierto de Apple, disponible mediante pip install coremltools. La biblioteca proporciona una API unificada para la conversión desde todos los frameworks soportados, así como herramientas de postprocesamiento: cuantización, verificación de precisión y visualización del grafo.

Instalación y conversión básica de modelo desde PyTorch:

import coremltools as ct
import torch
import torchvision

model = torchvision.models.resnet18(pretrained=True)
model.eval()

example_input = torch.rand(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

mlmodel = ct.convert(
    traced_model,
    source="pytorch",
    inputs=[ct.ImageType(shape=example_input.shape)]
)
mlmodel.save("ResNet18.mlmodel")

Para la conversión desde TensorFlow, use SavedModel como origen. coremltools determina automáticamente los tensores de entrada y salida según signature_def:

import coremltools as ct

mlmodel = ct.convert(
    "saved_model_dir",
    source="tensorflow",
    @minimum_deployment_target=ct.target.iOS16
)
mlmodel.save("MyTFModel.mlmodel")

Etapas de Conversión del Modelo

El proceso de conversión consta de cuatro etapas. En la primera etapa, coremltools carga el modelo de origen y realiza el trazado (tracing) o escaneo del grafo. Para PyTorch se utiliza torch.jit.trace, que ejecuta una entrada de muestra a través del modelo y registra la secuencia de operaciones.

En la segunda etapa se realiza el mapeo de operadores. Cada operador del grafo de origen se asigna a un operador de Core ML. Si no existe un reemplazo directo, coremltools divide el operador en una secuencia de operadores soportados. Según la documentación de coremltools, la cobertura de operadores de PyTorch supera el 95% para arquitecturas típicas.

La tercera etapa es la optimización del grafo. coremltools realiza fusión de operaciones (por ejemplo, conv + batch norm), eliminación de transformaciones innecesarias y reordenamiento de operadores para mejorar la eficiencia. La cuarta etapa es la serialización en el formato .mlmodel con preservación de pesos y metadatos.

Problemas Comunes y Sus Soluciones

El problema más frecuente en la conversión son las operaciones no soportadas. Si el modelo contiene un operador que falta en Core ML, coremltools informa un error con el nombre de la operación. La solución es reemplazar el operador con una combinación equivalente de operadores soportados o implementar una capa personalizada mediante la API de capas personalizadas.

El segundo problema es la discrepancia de dimensiones. PyTorch usa el formato NCHW, mientras que Core ML usa NHWC por defecto. coremltools inserta automáticamente la transposición, pero a veces el orden de los ejes se determina incorrectamente. Verifique las dimensiones de entrada y salida en los registros de conversión y, si es necesario, especifique input_features con los nombres correctos.

El tercer problema es la pérdida de precisión después de la cuantización. Al convertir con paleta FP16 o INT8, la precisión del modelo puede disminuir. coremltools proporciona la utilidad ct.models.CompiledModel para comparar las salidas del modelo original y convertido con los mismos datos de entrada. Si la discrepancia supera el 1%, use cuantización con paleta FP16 sin calibración o evite la cuantización por completo.

Ejemplos de Conversión desde PyTorch y TensorFlow

Un ejemplo de conversión del modelo MobileNetV3 desde PyTorch con especificación del tipo de entrada y versión mínima de iOS. Use ct.ImageType para la normalización automática de imágenes:

import coremltools as ct
import torchvision

model = torchvision.models.mobilenet_v3_small(
    pretrained=True
)
model.eval()
example = torch.rand(1, 3, 224, 224)
traced = torch.jit.trace(model, example)

mlmodel = ct.convert(
    traced,
    source="pytorch",
    inputs=[ct.ImageType(
        shape=example.shape,
        scale=1.0/255.0,
        bias=[0, 0, 0]
    )],
    @minimum_deployment_target=ct.target.iOS16
)

# Guardar en .mlmodel para compilación posterior en Xcode
mlmodel.save("MobileNetV3.mlmodel")

Un ejemplo de conversión desde TensorFlow Keras con cuantización FP16. Especifique minimum_deployment_target para habilitar soporte FP16 en dispositivos con Apple A13 y posteriores:

import coremltools as ct
from tensorflow import keras

keras_model = keras.applications.EfficientNetB0(
    weights="imagenet"
)

mlmodel = ct.convert(
    keras_model,
    source="tensorflow",
    @minimum_deployment_target=ct.target.iOS17
)

# Cuantizar pesos a FP16 para reducción de tamaño 2x
mlmodel_fp16 = ct.models.neural_network.quantization_utils.quantize_weights(
    mlmodel, 16
)
mlmodel_fp16.save("EfficientNetB0_fp16.mlmodel")