Exportação CoreML para modelos YOLO26#

A Apple inclui silício dedicado para IA — o Neural Engine — em todos os iPhone, iPad e Mac modernos, e o CoreML é atualmente o caminho compatível da Ultralytics para implementar modelos nesse hardware. Exportar modelos Ultralytics YOLO26 para CoreML transforma um checkpoint .pt treinado num .mlpackage nativo que executa todas as sete tarefas YOLO no dispositivo com baixa latência, sem ligação à rede e sem que os dados saiam do dispositivo.

O que é o CoreML?#

CoreML (apresentado como "Core ML" pela Apple) é o framework de aprendizagem automática no dispositivo da Apple. Carrega modelos no formato moderno ML Program — o pacote .mlpackage produzido pelo exportador da Ultralytics — e distribui-os pelo CPU, GPU e Apple Neural Engine (ANE) do dispositivo, a NPU dedicada presente em todos os chips Apple Silicon. Como tudo é executado localmente, a inferência funciona offline, não acrescenta latência de rede e mantém os dados do utilizador no dispositivo.

O CoreML integra-se diretamente com o framework Vision da Apple, que trata do redimensionamento e da orientação da imagem antes de esta entrar no modelo — é assim que o SDK iOS da Ultralytics fornece frames da câmara ao YOLO com um custo de pré-processamento praticamente nulo.

Porquê exportar YOLO26 para CoreML?#

• Velocidade do Neural Engine: o CoreML agenda operações compatíveis no Neural Engine da Apple para obter inferência no dispositivo com baixa latência. Consulta a tabela de dispositivos físicos abaixo e compara a tua exportação exata no hardware de destino.
• Escolhe a saída: as exportações padrão deixam o NMS para a tua aplicação. Usa nms=True para incorporar o NMS, ou nms=False para a cabeça sem NMS do YOLO26.
• Privado e offline: toda a computação permanece no dispositivo — sem comunicação de ida e volta com a cloud, sem chaves API e com total privacidade dos dados.
• Uma exportação, todo o ecossistema: o mesmo .mlpackage é executado em iOS, iPadOS, macOS, watchOS, tvOS e visionOS, e alimenta o iOS SDK e o plugin Flutter oficiais da Ultralytics.

Desempenho medido#

Inferência de ponta a ponta de uma única imagem para os recursos CoreML YOLO26n INT8 padronizados v8.3.0 num iPhone 17 Pro com 12 GB de memória e iOS 26.5.2. O seu A19 Pro tem um CPU de 6 núcleos (2 núcleos de Performance e 4 de Efficiency), um GPU de 6 núcleos com Neural Accelerators e um Neural Engine de 16 núcleos. Cada célula mostra o tempo total (pré-processamento + inferência + pós-processamento, excluindo a anotação), com a divisão por fase apresentada abaixo. No iOS, o Vision executa o redimensionamento da entrada dentro do pedido de inferência, pelo que o pré-processamento é indicado como 0 e o seu custo é incluído na inferência.

• Os recursos exatos da versão v8.3.0 declaram entradas de 224×224 para classificação e de 640×640 para todas as outras tarefas.
• Os valores de velocidade são latências de rajada de imagem única — a média de 15 execuções após 3 execuções de aquecimento em bus.jpg, medidas através da temporização por fase do iOS SDK com o sistema de benchmark do plugin Flutter no modo de perfil (código nativo otimizado). A ordem CPU/acelerador foi alternada entre tarefas numa única sequência. As linhas de CPU solicitam Core ML .cpuOnly; as linhas CPU + ANE preferido solicitam .cpuAndNeuralEngine, com a colocação final das operações controlada pelo Core ML. A operação sustentada da câmara em tempo real é mais lenta porque inclui o pipeline de captura e redimensionamento, além da estabilização térmica. Uma medição histórica de câmara anterior à padronização registou 11.3 ms/frame para deteção YOLO26n e 16.5 ms/frame para Depth YOLO26n no mesmo dispositivo — consulta o documento de desempenho do iOS SDK para a criação de perfis em estado estável.
• Compara os resultados de CPU/GPU Android na integração LiteRT e os resultados da NPU Snapdragon na integração Qualcomm QNN.

Tarefas suportadas#

A exportação CoreML suporta todas as sete tarefas da Ultralytics. A segmentação semântica e a estimativa de profundidade estão disponíveis apenas com YOLO26, a única família que inclui essas cabeças.

Exportar modelos YOLO26 para CoreML#

Instalação#

Para instalar o pacote necessário, executa:

# Install the required package for YOLO26
pip install ultralytics

O conversor coremltools é instalado automaticamente na primeira exportação. A exportação é executada em macOS ou Linux x86; para obter instruções detalhadas e boas práticas, consulta o nosso guia de instalação e o guia de problemas comuns.

Utilização#

O formato CoreML suporta os modos Exportar, Prever e Validar. A inferência e a validação com CoreML são executadas apenas em macOS. Exporta o teu modelo e carrega depois o modelo exportado para executar inferência ou validar a sua precisão.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export to CoreML with INT8 weight quantization, matching the official app models
model.export(format="coreml", quantize=8, imgsz=640)  # use imgsz=224 for classification

from ultralytics import YOLO

# Load the exported CoreML model (macOS)
model = YOLO("yolo26n.mlpackage")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Load the exported CoreML model (macOS)
model = YOLO("yolo26n.mlpackage")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Argumentos de Exportação#

Para obter mais detalhes sobre o processo de exportação, visita a página da documentação da Ultralytics sobre exportação.

Direcionar para o Neural Engine#

O CoreML escolhe o hardware através de MLModelConfiguration.computeUnits. O SDK iOS da Ultralytics usa por predefinição .cpuAndNeuralEngine no iOS 16+, em vez de .all: numa aplicação de câmara em tempo real, o GPU já está ocupado a compor a pré-visualização e as sobreposições, pelo que excluí-lo evita contenção e instabilidade no tempo de frame enquanto o ANE executa o trabalho pesado. Fixa .cpuOnly apenas para testes de compatibilidade — a tabela acima mostra o custo.

Executar um modelo CoreML a partir de Python num Mac anfitrião (através da Ultralytics ou de coremltools) segue a mesma regra: a Ultralytics carrega-o com ComputeUnit.CPU_AND_NE (macOS 13+, recuando para CPU_ONLY em versões mais antigas do macOS), mantendo a inferência no Neural Engine (cerca de 3× mais rápida do que no CPU). Isto também evita uma limitação atual do macOS anfitrião, em que as predefinições ComputeUnit.ALL / CPU_AND_GPU — que adicionam o caminho de compilação GPU/MPSGraph — interrompem o processo com uma asserção Error: MLIR pass manager failed em coremltools 9.x.

Implementar modelos YOLO26 CoreML exportados#

O caminho mais rápido é o Ultralytics YOLO iOS SDK oficial, o mesmo pacote Swift que alimenta a aplicação iOS da Ultralytics e o plugin Flutter. Resolve automaticamente os nomes oficiais dos modelos, transfere e coloca em cache o .mlpackage e devolve resultados totalmente descodificados:

import UltralyticsYOLO

// Loads the official INT8 model (downloaded and cached on first use), then runs inference
let yolo = YOLO("yolo26n", task: .detect) { result in
    if case .success(let model) = result {
        let results = model(uiImage)  // boxes, labels, confidences, timing
    }
}

Para aplicações de câmara, adiciona o YOLOView do SDK para obter inferência em tempo real com sobreposições nativas, ou usa o plugin Flutter para aplicações multiplataforma que partilham uma base de código com Android.

Também é simples integrar diretamente um .mlpackage bruto com a stack da Apple — carrega-o com MLModel, envolve-o num VNCoreMLRequest e fornece as imagens através de VNImageRequestHandler. Estes recursos explicam os detalhes:

• Integrar um modelo Core ML na tua aplicação: guia da Apple para incluir e chamar um modelo CoreML.
• CoreML Tools: referência de conversão, quantização e otimização para a cadeia de ferramentas coremltools que alimenta esta exportação.
• Relatórios de desempenho do Core ML no Xcode: criação de perfis de colocação por camada e latência para o teu modelo e dispositivo específicos.

Implementa o modelo incorporado no pacote da aplicação (disponibilidade imediata, ideal para modelos nano/pequenos) ou transfere-o na primeira execução e coloca-o em cache (binário menor e atualizações fáceis do modelo). As aplicações oficiais combinam ambas as abordagens: os modelos nano predefinidos vêm incluídos para utilização imediata, enquanto as variantes maiores são transferidas quando necessário e armazenadas localmente em cache.

Fluxo de Trabalho Recomendado#

1. Treina o teu modelo com o modo Train da Ultralytics ou começa pelos pesos oficiais YOLO26
2. Exporta com model.export(format="coreml", quantize=8, imgsz=640) em macOS ou Linux x86 (imgsz=224 para classificação)
3. Verifica a precisão com model.val() num Mac e cria um perfil com um relatório de desempenho Core ML do Xcode no teu dispositivo de destino
4. Implementa com o iOS SDK, o plugin Flutter ou a tua própria integração Vision, tendo como alvo .cpuAndNeuralEngine

Resumo#

Neste guia, aprendeste a exportar modelos Ultralytics YOLO26 para o formato .mlpackage do CoreML, quantizá-los para o Apple Neural Engine e implementá-los com latências de poucos milissegundos — através do iOS SDK e do plugin Flutter oficiais ou da tua própria integração Vision. Para outros destinos de implementação, consulta a página do guia de integrações e compara formatos com o modo Benchmark.

Perguntas frequentes#