Exportação CoreML para Modelos YOLO26#

A Apple disponibiliza silício dedicado para IA — o Neural Engine — em todos os iPhone, iPad e Mac modernos, e o CoreML é o caminho suportado pela Ultralytics para implantar modelos nele atualmente. Exportar modelos Ultralytics YOLO26 para CoreML transforma um checkpoint .pt treinado em um .mlpackage nativo que executa todas as sete tarefas YOLO no dispositivo com baixa latência, sem conexão de rede e sem que dados saiam do dispositivo.

O que é o CoreML?#

CoreML (estilizado como "Core ML" pela Apple) é o framework de machine learning no dispositivo da Apple. Ele carrega modelos no formato moderno ML Program — o pacote .mlpackage que o exportador Ultralytics produz — e os agenda através da CPU, GPU e Apple Neural Engine (ANE) do dispositivo, a NPU dedicada em cada chip Apple-silicon. Como tudo roda localmente, a inferência funciona offline, não adiciona latência de rede e mantém os dados do usuário no dispositivo.

O CoreML integra-se diretamente com o Vision framework da Apple, que lida com o redimensionamento e orientação da imagem a caminho do modelo — é assim que o Ultralytics iOS SDK fornece quadros da câmera para o YOLO com custo de pré-processamento efetivamente zero.

Por que exportar o YOLO26 para CoreML?#

• Velocidade do Neural Engine: O CoreML agenda operações suportadas no Neural Engine da Apple para inferência no dispositivo com baixa latência. Consulte a tabela de dispositivos físicos abaixo e faça o benchmark da sua exportação exata no seu hardware de destino.
• Sem NMS por design: O YOLO26 é end-to-end, portanto o grafo exportado não precisa de um pipeline de NMS e a decodificação leva menos de um milissegundo. Modelos de detecção mais antigos, como o YOLO11, podem incorporar um pipeline de NMS do CoreML com nms=True.
• Privado e offline: Toda a computação permanece no dispositivo — sem viagens de ida e volta à nuvem, sem chaves de API, total privacidade de dados.
• Uma exportação, todo o ecossistema: O mesmo .mlpackage roda no iOS, iPadOS, macOS, watchOS, tvOS e visionOS, e impulsiona o iOS SDK e o plugin Flutter oficiais da Ultralytics.

Desempenho Medido#

Inferência de imagem única de ponta a ponta para os ativos padronizados v8.3.0 YOLO26n INT8 CoreML em um iPhone 17 Pro com 12 GB de memória e iOS 26.5.2. O seu A19 Pro possui uma CPU de 6 núcleos (2 núcleos de Desempenho e 4 de Eficiência), GPU de 6 núcleos com Neural Accelerators e Neural Engine de 16 núcleos. Cada célula mostra o tempo total (pré-processamento + inferência + pós-processamento, excluindo anotação) com a divisão por estágio abaixo dela. No iOS, o Vision realiza o redimensionamento da entrada dentro da solicitação de inferência, portanto o pré-processamento é relatado como 0 e seu custo é incluído na inferência.

• Os ativos exatos da versão v8.3.0 declaram entradas de 224×224 para classificação e 640×640 para todas as outras tarefas.
• Os valores de Speed 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 por meio da temporização por estágio do iOS SDK através do framework de benchmark do Flutter plugin no modo de perfil (código nativo otimizado). A ordem de CPU/acelerador alternou entre as tarefas em uma varredura sequencial. As linhas de CPU solicitam Core ML .cpuOnly; as linhas de preferência por CPU + ANE solicitam .cpuAndNeuralEngine, com o posicionamento final da operação controlado pelo Core ML. A operação contínua da câmera em tempo real é executada em níveis mais altos porque inclui o pipeline de captura e redimensionamento mais a estabilização térmica. Uma varredura de câmera pré-padrão histórica mediu 11.3 ms/quadro para a detecção do YOLO26n e 16.5 ms/quadro para a profundidade do YOLO26n no mesmo dispositivo — consulte a documentação de desempenho do iOS SDK para o perfil em estado estacionário.
• Compare os resultados de CPU/GPU do Android na integração LiteRT e os resultados de NPU do Snapdragon na integração Qualcomm QNN.

Tarefas Suportadas#

A exportação para CoreML suporta todas as sete tarefas do 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.

Exportando Modelos YOLO26 para CoreML#

Instalação#

Para instalar o pacote necessário, execute:

# Install the required package for YOLO26
pip install ultralytics

O conversor coremltools é instalado automaticamente na primeira exportação. A exportação é executada no macOS ou Linux x86; para instruções detalhadas e melhores práticas, verifique nosso guia de instalação e o guia de Problemas Comuns.

Uso#

O formato CoreML suporta os modos Export, Predict e Validate. Inferência e validação com CoreML rodam apenas no macOS. Exporte seu modelo, carregue o modelo exportado para executar a inferência ou validar 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 mais detalhes sobre o processo de exportação, visite a página de documentação do Ultralytics sobre exportação.

Visando o Neural Engine#

O CoreML escolhe o hardware via MLModelConfiguration.computeUnits. O iOS SDK da Ultralytics define como padrão .cpuAndNeuralEngine no iOS 16+ em vez de .all: em um aplicativo de câmera em tempo real, a GPU já está ocupada compondo a pré-visualização e sobreposições, portanto, excluí-la evita contenção e jitter no tempo de quadro enquanto a ANE faz o trabalho pesado. Fixe .cpuOnly apenas para testes de compatibilidade — a tabela acima mostra qual é o custo.

Executar um modelo CoreML a partir do Python em um Mac host (via Ultralytics ou coremltools) segue a mesma regra: o Ultralytics é carregado com ComputeUnit.CPU_AND_NE (macOS 13+, recorrendo ao CPU_ONLY em versões mais antigas do macOS), mantendo a inferência no Neural Engine (~3× mais rápida que a CPU). Isso também evita uma limitação atual do host macOS onde o ComputeUnit.ALL / CPU_AND_GPU padrão — que adiciona o caminho de compilação da GPU/MPSGraph — interrompe o processo com uma asserção Error: MLIR pass manager failed no coremltools 9.x.

Implantando Modelos YOLO26 CoreML Exportados#

O caminho mais rápido é o Ultralytics YOLO iOS SDK oficial, o mesmo pacote Swift que impulsiona o aplicativo iOS da Ultralytics e o plugin Flutter. Ele resolve nomes oficiais de modelos automaticamente, baixa e armazena o .mlpackage em cache, e retorna resultados totalmente decodificados:

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 aplicativos de câmera, utilize o YOLOView do SDK para inferência em tempo real com sobreposições nativas, ou use o plugin Flutter para aplicativos multiplataforma que compartilham uma base de código com o Android.

Integrar um .mlpackage bruto você mesmo também é direto com a stack da Apple — carregue-o com MLModel, envolva-o em uma VNCoreMLRequest e forneça imagens através do VNImageRequestHandler. Estes recursos cobrem os detalhes:

• Integrando um Modelo Core ML em Seu Aplicativo: O guia da Apple para empacotar e chamar um modelo CoreML.
• CoreML Tools: Referência de conversão, quantização e otimização para a toolchain coremltools que impulsiona esta exportação.
• Relatórios de Desempenho Core ML do Xcode: Posicionamento no dispositivo por camada e perfil de latência para seu modelo e dispositivo exatos.

Envie o modelo embutido no pacote do aplicativo (disponibilidade instantânea, ideal para modelos nano/small) ou baixado na primeira execução e armazenado em cache (binário menor, atualizações de modelo fáceis). Os aplicativos oficiais combinam ambas as abordagens: os modelos nano padrão vêm embutidos para uso imediato, enquanto as variantes maiores são baixadas sob demanda e armazenadas em cache localmente.

Fluxo de Trabalho Recomendado#

1. Treine seu modelo com o modo Train da Ultralytics, ou comece a partir dos pesos oficiais do YOLO26
2. Exporte com model.export(format="coreml", quantize=8, imgsz=640) no macOS ou x86 Linux (imgsz=224 para classificação)
3. Verifique a precisão com model.val() em um Mac, e crie um perfil com um Relatório de Desempenho Core ML do Xcode no seu dispositivo de destino
4. Implante com o iOS SDK, o plugin Flutter, ou sua própria integração Vision, visando .cpuAndNeuralEngine

Resumo#

Neste guia, você aprendeu como exportar modelos YOLO26 da Ultralytics para o formato .mlpackage do CoreML, quantizá-los para o Apple Neural Engine e implantá-los com latências de milissegundos de um único dígito — seja através do iOS SDK oficial e plugin Flutter ou sua própria integração Vision. Para outros destinos de implantação, navegue pela página do guia de integração, e compare formatos com o modo Benchmark.

FAQ#

Como exporto modelos YOLO26 para o formato CoreML?#

Execute model.export(format="coreml", imgsz=640) em Python ou yolo export model=yolo26n.pt format=coreml imgsz=640 a partir da CLI no macOS ou x86 Linux. Use imgsz=224 para classificação e adicione quantize=8 para corresponder aos modelos oficiais do aplicativo. A exportação produz um programa ML yolo26n.mlpackage pronto para o Xcode, o iOS SDK ou o plugin Flutter.

Eu preciso de nms=True ao exportar o YOLO26?#

Não. O YOLO26 não utiliza NMS end-to-end, por isso o grafo exportado já emite detecções finais e os custos de decodificação são bem inferiores a um milissegundo. A opção nms=True existe para modelos de detecção anteriores, como o YOLO11, nos quais ela incorpora um pipeline de NMS do CoreML para que o seu aplicativo não precise implementar a supressão. Os pipelines de NMS do CoreML suportam apenas detecção de objetos, portanto nms=True é ignorado com um aviso para outras tarefas, como segmentação e pose.

Qual precisão devo usar — FP16 ou INT8?#

Os modelos oficiais do aplicativo Ultralytics são fornecidos como INT8, o que minimiza o tamanho do download e roda nas velocidades indicadas na tabela acima. quantize=16 (FP16) é uma alternativa conservadora sem perda de precisão praticamente. Valide sua exportação exata com model.val() em um Mac antes de disponibilizar.

Como garanto que a inferência rode no Neural Engine?#

Defina MLModelConfiguration.computeUnits = .cpuAndNeuralEngine (o padrão do iOS SDK no iOS 16+). Evite .all em aplicativos de câmera — a GPU está ocupada compondo a pré-visualização, e agendar a inferência lá causa jitter no tempo de quadro. Confirme o posicionamento com um Relatório de Desempenho Core ML do Xcode.

Posso executar e validar modelos CoreML com a CLI da Ultralytics?#

Sim, no macOS: yolo predict model=yolo26n.mlpackage source=image.jpg e yolo val model=yolo26n.mlpackage data=coco8.yaml funcionam como qualquer outro formato. A execução CoreML requer hardware Apple, portanto esses modos não estão disponíveis no Linux e Windows.

Qual é a maneira mais rápida de colocar o YOLO26 para rodar em um aplicativo iOS ou Flutter?#

Use o Ultralytics YOLO iOS SDK (Swift Package) oficial ou o plugin Flutter. Ambos carregam modelos oficiais pelo nome com download e cache automáticos, executam-nos no Neural Engine e incluem IUs de câmera em tempo real completas — a tabela de desempenho medida acima foi produzida exatamente com essa stack.