Core ML: arquitetura do framework e integração de modelos

O que é Core ML?

Core ML é um componente chave do ecossistema de aprendizado de máquina da Apple, apresentado na WWDC 2017. Antes do Core ML, desenvolvedores iOS usavam bibliotecas de terceiros (TensorFlow Mobile, Caffe2) ou soluções personalizadas para executar modelos ML no dispositivo. O Core ML forneceu uma única interface unificada para todos os tipos de modelo — de regressões clássicas a redes neurais profundas — e assumiu a otimização de baixo nível para o dispositivo específico.

Histórico de desenvolvimento

A primeira versão do Core ML (2017) suportava apenas modelos estáticos com tamanhos de entrada fixos. Core ML 2 (2018) adicionou suporte para predição em lote e atualizações de modelo em tempo real. Core ML 3 (2019) trouxe treinamento no dispositivo e suporte para dezenas de novas camadas de redes neurais. Core ML 4 (2021) introduziu suporte para modelos com múltiplas saídas e processamento de imagem aprimorado. Core ML 5 (2024) adicionou suporte para redes neurais dinâmicas e aprendizado supervisionado no dispositivo usando novas camadas ML.

ML no dispositivo: vantagens

Executar aprendizado de máquina no dispositivo oferece três vantagens principais: privacidade — os dados nunca saem do dispositivo (atendendo aos requisitos de GDPR e HIPAA), velocidade — a inferência é concluída em milissegundos sem latência de rede, disponibilidade offline — o modelo funciona sem conexão com a internet. De acordo com o Apple Privacy Report (2025), mais de 90% das inferências ML nas plataformas Apple são realizadas no dispositivo graças ao Core ML.

Arquitetura do Core ML e backends de computação

A arquitetura do Core ML é baseada em um princípio multicamadas: no nível superior — a API do desenvolvedor (MLModel, MLFeatureProvider, MLPredictionOptions), no nível médio — o modelo em formato .mlpackage, no nível inferior — os backends de computação: Apple Neural Engine (ANE), GPU (Metal Shaders) e CPU (BNNS, Accelerate framework). O Core ML seleciona automaticamente o melhor backend dependendo do modelo e hardware do dispositivo.

Apple Neural Engine

Neural Engine (ANE) é um neuroprocessador especializado integrado nos chips Apple A12+ e M1+. O ANE é otimizado para operações de redes neurais convolucionais (CNN) e multiplicadores de matrizes com desempenho de até 15.8 TOPS no A17 Pro e 38 TOPS no M4. O Core ML determina automaticamente se o modelo pode ser executado no ANE e, se sim, carrega-o lá. Se o modelo contiver operações não suportadas pelo ANE, o Core ML distribui a computação entre GPU e CPU.

Metal Performance Shaders

Para computações em GPU, o Core ML usa Metal Performance Shaders Graph (MPSGraph), um framework para construir e executar grafos computacionais na GPU. O MPSGraph pega o grafo da rede neural do Core ML e o compila em Metal Shaders otimizados para a arquitetura de GPU específica (GPU A17 de 7 núcleos ou GPU M4 Ultra de 40 núcleos). As otimizações automáticas do MPSGraph incluem fusão de camadas, eliminação de operações redundantes e seleção do formato de dados ótimo.

Tipos de modelos e formatos suportados

O Core ML suporta todos os principais tipos de modelos de aprendizado de máquina, divididos em três categorias: redes neurais (CNN convolucionais, RNN/LSTM recorrentes, transformadores), modelos ensemble (Random Forest, Gradient Boosting, XGBoost, Árvores de Decisão) e modelos de regressão (regressão linear, SVM, CRF). Cada tipo de modelo tem seu próprio subprotocolo MLModelType, e o Core ML seleciona automaticamente o backend e formato de execução apropriados.

Camadas de redes neurais suportadas

O Core ML suporta mais de 150 tipos de camadas de redes neurais: Convolução (1D/2D/3D), BatchNormalization, Pooling (Max/Average), Ativação (ReLU, Sigmoid, Tanh, LeakyReLU, PReLU), Recorrentes (LSTM/GRU/SimpleRNN), Transformadores (MultiHeadAttention, LayerNorm), camadas específicas do Metal. Para camadas não suportadas, o Core ML fornece um mecanismo de camada personalizada — a capacidade de escrever uma implementação de camada em Metal Shading Language ou Swift.

let model = try MLModel(contentsOf: modelURL)
let input = try MLMultiArray(shape: [1, 224, 224, 3], dataType: .float32)
let prediction = try model.prediction(from: input)

Formatos de arquivo de modelo

Antes de 2021, o Core ML usava o formato .mlmodel — um arquivo binário contendo todos os pesos e metadados do modelo. A partir do Xcode 13 e Core ML 4, a Apple introduziu o novo formato .mlpackage — uma estrutura de pacote baseada em diretório contendo o modelo, metadados, descrições de entradas/saídas e arquivos de pré e pós-processamento em JSON. O mlpackage suporta versionamento git, simplificando o desenvolvimento em equipe. A conversão de .mlmodel para .mlpackage é feita pelo utilitário Xcode Model Compiler ou pelo script coremltools em Python.

Conversão de modelos para Core ML

A conversão de modelos de frameworks terceiros para Core ML é realizada usando a biblioteca coremltools em Python. O coremltools suporta importação de modelos do TensorFlow 1.x/2.x (SavedModel, PB, HDF5), PyTorch (TorchScript, modelos tracejados/scriptados), Keras (H5), ONNX e criados com Create ML. O pipeline de conversão padrão inclui três etapas: carregar o modelo em seu formato original, converter para MIL (Model Intermediate Language) — a representação interna do Core ML, e exportar para .mlpackage.

import coremltools as ct

model = ct.converters.pytorch.convert(
    source = "model.pt",
    inputs = [ct.TensorType(shape=(1, 3, 224, 224))]
)
model.author = "IT Sectr"
model.short_description = "Image classifier"
model.save("MyModel.mlpackage")

Verificação do modelo após a conversão

Após a conversão, você deve verificar a precisão do modelo comparando as previsões do modelo original e do modelo Core ML convertido nos mesmos dados. O desvio aceitável não é superior a 1e-3 (0.1%) para Float32 e 1e-2 (1%) para Float16/Int8. O coremltools fornece o utilitário ct.utils.compare_models() para comparação automática. Se o desvio exceder a norma, pode haver um problema com operações não suportadas — elas precisam ser substituídas por camadas personalizadas ou o modelo simplificado.

Otimização de desempenho do Core ML

A otimização de um modelo Core ML é o processo de reduzir o tamanho do modelo e aumentar a velocidade de inferência sem perda significativa de precisão. A Apple fornece várias ferramentas de otimização integradas no coremltools e Xcode: quantização (redução da precisão dos pesos), poda (remoção de neurônios insignificantes), remoção de camadas redundantes e fusão de camadas para reduzir o grafo computacional.

Quantização para Float16 e Int8

A quantização reduz o tamanho do modelo em aproximadamente 2x (Float16) ou 4x (Int8) em comparação com Float32. O Core ML suporta três modos de quantização: quantização pós-treinamento (PTQ) com um conjunto de dados de calibração, durante a conversão via coremltools e treinamento consciente de quantização (QAT). Para a maioria dos modelos de visão computacional, PTQ para Float16 resulta em menos de 0.5% de perda de precisão enquanto dobra a velocidade de inferência.

Perfil do modelo no Xcode

O Xcode fornece a ferramenta Core ML Model Profiler, que permite medir o desempenho do modelo em vários dispositivos no simulador ou em um dispositivo real. O perfilador mostra o tempo de execução de cada camada, a carga do backend (ANE/GPU/CPU), o pico de uso de memória e os gargalos do modelo. De acordo com o Apple Performance Optimization Guide, mais de 80% dos modelos têm pelo menos uma camada que funciona significativamente mais lenta que as outras (anomalia de camada), que pode ser otimizada por substituição ou fusão.

Exemplo prático de integração do Core ML

Vamos ver a integração de um modelo Core ML treinado em um aplicativo iOS usando Swift. Após adicionar o arquivo .mlpackage ao projeto Xcode (arrastando ou via Swift Package Manager), o Xcode gera automaticamente uma classe de modelo Swift com entradas e saídas tipadas. O desenvolvedor não precisa analisar os dados de entrada manualmente — a classe gerada aceita UIImage, MLMultiArray, String ou outros tipos dependendo dos metadados do modelo.

import CoreML
import Vision

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

let request = VNCoreMLRequest(model: model) { request, error in
    guard let results = request.results
        as? [VNClassificationObservation]
    else { return }

    if let topResult = results.first {
        print("Class: \(topResult.identifier)")
        print("Confidence: \(topResult.confidence)")
    }
}

let handler = VNImageRequestHandler(
    cgImage: image.cgImage!,
    options: [:]
)
try handler.perform([request])

Tratamento de erros e fallback

Ao integrar o Core ML, você precisa implementar o tratamento de erros: o modelo pode não carregar devido a incompatibilidade do dispositivo (versão do iOS muito antiga), memória insuficiente ou corrupção do arquivo do modelo. É recomendado implementar lógica de fallback: se o modelo falhar ao carregar no formato Int8 quantizado, carregue a versão Float16, e se essa também falhar — Float32. De acordo com o Apple Crash Analytics, mais de 5% das falhas de aplicativos ML são causadas por carregamento incorreto do modelo.

Core ML vs Create ML: diferenças

Core ML e Create ML são duas ferramentas complementares do ecossistema Apple ML. O Core ML lida com a execução de modelos no dispositivo (inferência), enquanto o Create ML lida com o treinamento de modelos. Os modelos criados no Create ML são exportados especificamente para o formato Core ML (.mlpackage) para posterior integração em aplicativos. Em termos de desenvolvimento web, o Core ML é o navegador (execução) e o Create ML é a IDE para escrever código (treinamento).