Conversão de Modelos Core ML: o que é, etapas e métodos de conversão

O que é Core ML Model Conversion

Core ML Model Conversion é o processo de transformar um modelo de machine learning treinado do formato do framework de origem para o formato .mlmodel compreendido pelo Core ML Runtime em dispositivos Apple. Sem conversão, um modelo treinado em PyTorch ou TensorFlow não pode ser carregado e executado no iOS ou macOS diretamente.

O processo de conversão inclui a tradução do grafo de computação: cada operador do framework de origem (Conv2D, BatchNorm, ReLU) é mapeado para o operador Core ML correspondente. Se não existir uma substituição direta, o coremltools usa operações compostas ou camadas personalizadas. De acordo com a Apple ML Research, a biblioteca cobre mais de 200 operadores de vários frameworks.

Após a conversão, o modelo é salvo no formato de pacote .mlmodel, que inclui uma descrição do grafo em protobuf, pesos em formato binário e metadados. Este arquivo é então compilado em mlmodelc para execução no dispositivo de destino.

Frameworks e Formatos Suportados

O coremltools versão 7.x suporta conversão de seis fontes. PyTorch — via torch.jit.trace ou torch.export, TensorFlow 2.x — via SavedModel e Keras H5, TensorFlow 1.x — via grafo congelado .pb. Para ONNX, é usada uma representação intermediária, que é então traduzida para Core ML.

Matriz de Compatibilidade de Frameworks

Ferramentas de Conversão: coremltools

O coremltools é a biblioteca Python oficial de código aberto da Apple, disponível via pip install coremltools. A biblioteca fornece uma API unificada para conversão de todos os frameworks suportados, bem como ferramentas de pós-processamento: quantização, verificação de precisão e visualização de grafo.

Instalação e conversão básica de modelo do 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 conversão do TensorFlow, use SavedModel como origem. O coremltools determina automaticamente os tensores de entrada e saída com base no 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 da Conversão do Modelo

O processo de conversão consiste em quatro etapas. Na primeira etapa, o coremltools carrega o modelo de origem e realiza o rastreamento (tracing) ou escaneamento do grafo. Para PyTorch, é usado torch.jit.trace, que executa uma entrada de amostra através do modelo e registra a sequência de operações.

Na segunda etapa, é realizado o mapeamento de operadores. Cada operador do grafo de origem é mapeado para um operador Core ML. Se não existir uma substituição direta, o coremltools divide o operador em uma sequência de operadores suportados. De acordo com a documentação do coremltools, a cobertura de operadores do PyTorch excede 95% para arquiteturas típicas.

A terceira etapa é a otimização do grafo. O coremltools realiza fusão de operações (por exemplo, conv + batch norm), remoção de transformações desnecessárias e reordenação de operadores para melhorar a eficiência. A quarta etapa é a serialização no formato .mlmodel com preservação de pesos e metadados.

Problemas Comuns e Suas Soluções

O problema mais frequente na conversão são operações não suportadas. Se o modelo contém um operador ausente no Core ML, o coremltools relata um erro com o nome da operação. A solução é substituir o operador por uma combinação equivalente de operadores suportados ou implementar uma camada personalizada através da API de camadas personalizadas.

O segundo problema é a discrepância de dimensões. PyTorch usa o formato NCHW, enquanto o Core ML usa NHWC por padrão. O coremltools insere automaticamente a transposição, mas às vezes a ordem dos eixos é determinada incorretamente. Verifique as dimensões de entrada e saída nos logs de conversão e, se necessário, especifique input_features com os nomes corretos.

O terceiro problema é a perda de precisão após a quantização. Ao converter com paleta FP16 ou INT8, a precisão do modelo pode diminuir. O coremltools fornece o utilitário ct.models.CompiledModel para comparar as saídas do modelo original e convertido nos mesmos dados de entrada. Se a discrepância exceder 1%, use quantização com paleta FP16 sem calibração ou evite a quantização completamente.

Exemplos de Conversão do PyTorch e TensorFlow

Um exemplo de conversão do modelo MobileNetV3 do PyTorch com especificação do tipo de entrada e versão mínima do iOS. Use ct.ImageType para normalização automática de imagens:

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
)

# Salvar em .mlmodel para compilação posterior no Xcode
mlmodel.save("MobileNetV3.mlmodel")

Um exemplo de conversão do TensorFlow Keras com quantização FP16. Especifique minimum_deployment_target para ativar o suporte FP16 em dispositivos com Apple A13 e 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
)

# Quantizar pesos para FP16 para redução de 2x no tamanho
mlmodel_fp16 = ct.models.neural_network.quantization_utils.quantize_weights(
    mlmodel, 16
)
mlmodel_fp16.save("EfficientNetB0_fp16.mlmodel")