Exportação CoreML para Modelos YOLO26#

A Apple inclui silício de IA dedicado — 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 do Ultralytics YOLO26 para o CoreML transforma um checkpoint treinado do .pt em um .mlpackage nativo que executa todas as sete tarefas do YOLO no dispositivo com baixa latência, sem conexão de rede e sem que nenhum dado saia do dispositivo.

O que é o CoreML?#

O CoreML (chamado de "Core ML" pela Apple) é o framework de machine learning para execução no dispositivo da Apple. Ele carrega modelos no formato moderno ML Program — o pacote .mlpackage gerado pelo exportador da Ultralytics — e os distribui entre a CPU, a GPU e o Apple Neural Engine (ANE) do dispositivo, a NPU dedicada em cada chip de silício da Apple. Como tudo é executado 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 ao framework Vision da Apple, que lida com o redimensionamento e a orientação de imagens na entrada para o modelo — é assim que o iOS SDK da Ultralytics fornece quadros de 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.
• Livre de NMS por design: O YOLO26 é end-to-end, portanto o grafo exportado não precisa de 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 idas e vindas à nuvem, sem chaves de API, com total privacidade de dados.
• Uma exportação, todo o ecossistema: O mesmo .mlpackage é executado no iOS, iPadOS, macOS, watchOS, tvOS e visionOS, e alimenta o iOS SDK e o plugin Flutter oficiais da Ultralytics.

Desempenho Medido#

Inferência de imagem única end-to-end para os ativos CoreML INT8 do YOLO26n padronizados v8.3.0 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 exibe o tempo total (pré-processamento + inferência + pós-processamento, excluindo anotação) com a divisão por etapa logo abaixo. No iOS, o Vision realiza o escalonamento de entrada dentro da solicitação de inferência, portanto o pré-processamento é relatado como 0 e seu custo está incluído na inferência.

• Os ativos exatos de lançamento de 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 contagem de tempo por etapa do iOS SDK através do mecanismo de benchmark do plugin Flutter no modo profile (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 CPU + ANE preferido solicitam .cpuAndNeuralEngine, com o posicionamento final das operações controlado pelo Core ML. A operação de câmera em tempo real contínua é mais lenta porque inclui o pipeline de captura e escala mais a estabilização térmica. Uma varredura de câmera pré-padronizada histórica mediu 11,3 ms/quadro para a detecção do YOLO26n e 16,5 ms/quadro para o YOLO26n Depth no mesmo dispositivo — consulte a documentação de desempenho do iOS SDK para o perfil em regime permanente.
• Compare os resultados de CPU/GPU do Android na integração LiteRT e os resultados de NPU 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 práticas recomendadas, consulte nosso guia de instalação e o guia de Problemas Comuns.

Uso#

O formato CoreML suporta os modos Export, Predict e Validate. A inferência e a validação com o CoreML são executadas apenas no macOS. Exporte seu modelo e, em seguida, 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, visita a página de documentação do Ultralytics sobre exportação.

Visando o Neural Engine#

O CoreML escolhe o hardware por meio de MLModelConfiguration.computeUnits. O SDK do iOS da Ultralytics usa por 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 as sobreposições, portanto, excluí-la evita contenção e oscilação no tempo dos quadros enquanto o ANE faz o trabalho pesado. Defina .cpuOnly apenas para testes de compatibilidade — a tabela acima mostra o custo disso.

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

Implantando Modelos YOLO26 CoreML Exportados#

O caminho mais rápido é o iOS SDK do YOLO da Ultralytics oficial, o mesmo pacote Swift que alimenta o aplicativo iOS da Ultralytics e o plugin Flutter. Ele resolve nomes de modelos oficiais automaticamente, baixa e armazena em cache o .mlpackage 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, insira 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 única base de código com o Android.

Integrar um .mlpackage bruto por conta própria também é simples com a pilha da Apple — carregue-o com MLModel, envolva-o em um VNCoreMLRequest e envie imagens por meio de VNImageRequestHandler. Estes recursos cobrem os detalhes:

• Integrating a Core ML Model into Your App: Guia da Apple sobre como empacotar 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.
• Xcode Core ML Performance Reports: Posicionamento de dispositivo por camada e perfil de latência para o 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 com os pesos oficiais do YOLO26
2. Exporte com model.export(format="coreml", quantize=8, imgsz=640) no macOS ou Linux x86 (imgsz=224 para classificação)
3. Verifique a precisão com model.val() em um Mac e faça o perfil com um relatório de desempenho do Xcode Core ML no seu dispositivo de destino
4. Implante com o iOS SDK, o plugin Flutter ou sua própria integração Vision, tendo como alvo .cpuAndNeuralEngine

Resumo#

Neste guia, você aprendeu como exportar modelos do Ultralytics YOLO26 para o formato .mlpackage do CoreML, quantizá-los para o Apple Neural Engine e implantá-los com latências de um dígito em milissegundos — seja por meio do iOS SDK oficial e plugin Flutter ou de 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#