Core ML — o que é, modelo de aprendizado de máquina e funcionamento no iOS

O que é Core ML?

Core ML é um framework de aprendizado de máquina apresentado pela Apple na WWDC 2017 como parte do ecossistema de desenvolvimento para iPhone, iPad, Mac, Apple Watch e Apple TV. O Core ML fornece um runtime para executar modelos ML no dispositivo, abstraindo o desenvolvedor dos detalhes de otimização de hardware. O framework seleciona automaticamente o melhor mecanismo de computação — Neural Engine em chips A12+, GPU ou CPU — para cada operação do modelo.

A principal vantagem do Core ML é a integração profunda com o Apple Silicon. As operações de redes neurais são executadas no Neural Engine dedicado, que não sobrecarrega os núcleos principais do processador. De acordo com a Apple (WWDC 2025), os modelos Core ML funcionam 6 vezes mais rápido em comparação com o TensorFlow Lite em dispositivos Android similares.

Principais Recursos

Core ML suporta uma ampla gama de tarefas de aprendizado de máquina: classificação de imagens, detecção de objetos, segmentação semântica, processamento de linguagem natural, análise de som e dados tabulares. O framework trabalha com vários tipos de modelos: redes neurais (convolucionais, recorrentes, transformers), ensembles de árvores, regressões lineares e processos gaussianos.

Como o Core ML Funciona

Core ML recebe um modelo treinado no formato .mlpackage, compila-o em código de máquina otimizado para o dispositivo específico e executa a inferência através de uma API unificada. Todo o pipeline — desde o carregamento do modelo até a obtenção do resultado — requer 3–5 linhas de código Swift.

Formato de Modelo .mlpackage

.mlpackage é um formato contêiner introduzido pela Apple em 2020 para substituir o antigo .mlmodel. O pacote é um diretório contendo um manifesto JSON, um arquivo de modelo no formato binário MLProgram, metadados (autor, versão, descrição) e recursos como rótulos de classes. Segundo a Apple, o .mlpackage reduz o tamanho do modelo em 30–50% em comparação com o .mlmodel através da otimização de pesos.

Apple Neural Engine

Apple Neural Engine (ANE) é um neuroprocessador dedicado integrado aos chips Apple a partir do A12 Bionic (2018). O ANE processa operações matriciais dezenas de vezes mais eficientemente que a CPU com o mesmo consumo de energia. O desempenho do ANE cresceu de 5 TOPS no A12 para 35 TOPS no M4 Ultra (2025), permitindo executar modelos com bilhões de parâmetros. O ANE é usado automaticamente para todos os modelos Core ML com arquitetura de redes neurais.

Uma característica importante do Core ML é o suporte para quantização de modelos para FP16 e INT8 sem perda de precisão. A quantização reduz o tamanho do modelo em 2–4 vezes e acelera a inferência em 40–60% no ANE. A Apple fornece a ferramenta Xcode Model Quantization para seleção automática da precisão ideal: o desenvolvedor carrega um modelo, especifica a perda de qualidade aceitável (geralmente 0.1–0.5%), e o Xcode seleciona o melhor formato de representação de pesos.

Comparação de Desempenho do Core ML

Convertendo Modelos para Core ML

A maioria dos modelos ML são criados em PyTorch ou TensorFlow e precisam de conversão para o formato .mlpackage para uso no Core ML. A Apple fornece o utilitário coremltools — um pacote Python para converter, otimizar e validar modelos.

Ferramenta coremltools

coremltools é o utilitário oficial da Apple para converter modelos ML. Ele suporta importação do PyTorch (via torch.onnx ou diretamente), TensorFlow (SavedModel, H5, Frozen Graph) e ONNX. Após a conversão, a quantização FP16 ou INT8 pode ser ativada, reduzindo o tamanho do modelo em 2–4 vezes sem perda significativa de precisão.

Exemplo de Conversão do PyTorch

Vamos analisar a conversão de um modelo treinado PyTorch para o formato Core ML usando coremltools versão 8.0. O processo requer 2–3 passos em Python.

import torch
import coremltools as ct

# Carregando modelo PyTorch treinado
model = torch.load('model.pth')
model.eval()

# Traçando modelo com entrada de exemplo
example_input = torch.randn(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

# Convertendo para Core ML .mlpackage
mlmodel = ct.convert(
    traced_model,
    convert_to='mlprogram',
    inputs=[ct.TensorType(shape=(1, 3, 224, 224))]
)
mlmodel.save('Model.mlpackage')

O código carrega o modelo PyTorch treinado, realiza o tracing JIT com uma entrada de exemplo e o converte para o formato mlprogram (formato binário do Core ML). O .mlpackage resultante pode ser arrastado para o Xcode e usado imediatamente em código Swift.

Integrando Core ML em um App iOS

Após a conversão do modelo, sua integração em um app iOS em Swift é feita em poucas linhas. O Xcode gera automaticamente uma classe Swift para o modelo com base nos metadados do .mlpackage.

Exemplo de Código Swift

Vamos analisar um exemplo de classificação de imagens usando Core ML e o framework Vision. O Vision transforma automaticamente a imagem para o tamanho e formato de pixels necessários.

import CoreML
import Vision

// Carregando modelo Core ML
guard let model = try? VNCoreMLModel(
    for: MobileNetV2.configuration.model
) else { return }

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

    // Exibindo top-3 previsões
    for result in results.prefix(3) {
        print("\(result.identifier):
              \(result.confidence)")
    }
}

// Iniciando processamento de imagem
let handler = VNImageRequestHandler(
    url: imageURL
)
try? handler.perform([request])

O código Swift carrega o modelo MobileNetV2 através do framework Vision, cria uma solicitação de classificação e processa o resultado — um array de objetos VNClassificationObservation com rótulos de classe e percentuais de confiança. Todo o pipeline, do carregamento à saída do resultado, leva 5–50 ms dependendo do modelo.

Para otimizar o tempo de inicialização, o Core ML compila o modelo no primeiro uso. A compilação prévia reduz a inicialização a frio de 2–3 segundos para 100–200 ms. Recomenda-se compilar o modelo em tempo de construção no Xcode, não na primeira execução do aplicativo. Isso é especialmente importante para aplicativos com múltiplos modelos ML — por exemplo, detecção de objetos + classificação + NLP.

Core ML vs ML Kit

Core ML e ML Kit resolvem tarefas similares de ML no dispositivo, mas são direcionados a ecossistemas diferentes. O Core ML é profundamente integrado ao Apple Silicon e suporta apenas plataformas Apple. O ML Kit do Google é uma solução multiplataforma para Android e iOS.

Escolha Core ML se seu ecossistema for exclusivamente Apple e você precisar de máximo desempenho através do ANE. Se precisar de suporte multiplataforma ou APIs prontas sem conversão, o ML Kit será mais prático.

Na prática, muitos projetos usam ambos os frameworks: iOS Core ML para alto desempenho, e ML Kit ou TensorFlow Lite no Android. Um modelo PyTorch unificado é convertido para .mlpackage para Apple e para .tflite para Android, permitindo manter a mesma qualidade de recursos ML em ambas as plataformas. Esta abordagem requer um pouco mais de esforço em DevOps, mas proporciona a máxima cobertura de público.

Ao escolher entre Core ML e alternativas, considere o custo de desenvolvimento: Core ML requer menos código de integração (3–5 linhas de Swift contra 15–20 linhas com TFLite), mas requer Mac e Xcode para compilar. ML Kit, por outro lado, funciona em qualquer plataforma, mas oferece menor desempenho no iOS devido à falta de acesso ao Apple Neural Engine.