Link to this sectionExportaçã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.

Link to this sectionO 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.

Link to this sectionPor que exportar o YOLO26 para CoreML?#

• Velocidade do Neural Engine: A detecção YOLO26n é executada de ponta a ponta em 3,8 ms em um iPhone 17 Pro para imagens únicas e 11,3 ms/frame em uso contínuo de câmera em tempo real; o YOLO26n Depth leva 5,5 ms para uma imagem única e 16,5 ms/frame na câmera ao vivo (veja a tabela e as notas abaixo).
• 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.

Link to this sectionDesempenho Medido#

Inferência de imagem única de ponta a ponta para os modelos oficiais YOLO26n INT8 CoreML em um iPhone 17 Pro (Apple A19, iOS 26.5.2). 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 escalonamento da entrada dentro da solicitação de inferência, portanto, o pré-processamento é relatado como 0 e seu custo está incluído na inferência.

• ¹ Exportações semânticas do CoreML incorporam o ArgMax no grafo e retornam um mapa de classes compacto em resolução total ([1, 1024, 1024]) em vez de logits flutuantes, portanto o pós-processamento é uma varredura de cores sub-milissegundo e as máscaras são renderizadas com nitidez de pixel.
• Os valores de Velocidade são latências de burst de imagem única — a média de 15 execuções após 3 execuções de aquecimento em bus.jpg, medidas através do temporizador por estágio do iOS SDK's via harness de benchmark do plugin Flutter em modo de perfil (código nativo otimizado). A operação contínua de câmera em tempo real é mais alta porque inclui o pipeline de captura e escalonamento mais a estabilização térmica: o YOLO26n detect mede 11,3 ms/frame e o YOLO26n Depth 16,5 ms/frame no aplicativo de câmera ao vivo no mesmo dispositivo — veja o documento de desempenho do iOS SDK para perfil de estado estacionário.
• A tabela correspondente de CPU/GPU/NPU Snapdragon está na integração Qualcomm QNN.

Link to this sectionExportando Modelos YOLO26 para CoreML#

Link to this sectionInstalaçã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.

Link to this sectionUso#

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)  # creates 'yolo26n.mlpackage'

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")

Link to this sectionArgumentos de Exportação#

Para mais detalhes sobre o processo de exportação, visite a página de documentação do Ultralytics sobre exportação.

Link to this sectionVisando 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.

Link to this sectionImplantando 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.

Distribua o modelo incorporado 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 usam a segunda abordagem com os assets de release do GitHub.

Link to this sectionFluxo 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) no macOS ou Linux x86
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

Link to this sectionResumo#

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.

Link to this sectionFAQ#

Link to this sectionComo exporto modelos YOLO26 para o formato CoreML?#

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

Link to this sectionEu 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.

Link to this sectionQual 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.

Link to this sectionComo 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.

Link to this sectionPosso 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.

Link to this sectionQual é 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.