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 é o caminho compatível da Ultralytics para implantar modelos nele atualmente. Exportar modelos Ultralytics YOLO26 para CoreML converte um checkpoint .pt treinado em um .mlpackage nativo, que executa no dispositivo todas as sete tarefas YOLO com baixa latência, sem conexão de rede e sem que os dados saiam do dispositivo.

O que é CoreML?#

CoreML (estilizado como "Core ML" pela Apple) é o framework de aprendizado de máquina da Apple para dispositivos. Ele carrega modelos no formato moderno ML Program — o pacote .mlpackage produzido pelo exportador da Ultralytics — e os agenda na CPU, GPU e Mecanismo Neural da Apple (ANE) do dispositivo, o NPU dedicado em cada chip Apple Silicon. 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.

CoreML integra-se diretamente ao framework Vision da Apple, que processa o redimensionamento e a orientação da imagem antes de ela entrar no modelo — é assim que o SDK Ultralytics para iOS envia quadros da câmera ao YOLO praticamente sem custo de pré-processamento.

Por que exportar YOLO26 para CoreML?#

• Velocidade do Neural Engine: CoreML agenda as operações compatíveis no Neural Engine da Apple para inferência de baixa latência no dispositivo. Consulta a tabela de dispositivos físicos abaixo e avalia o teu export específico no hardware de destino.
• Escolhe a saída: os exports padrão deixam o NMS a cargo da tua aplicação. Usa nms=True para incorporar NMS ou nms=False para a cabeça do YOLO26 sem NMS.
• Privado e offline: todo o processamento permanece no dispositivo — sem idas e voltas à nuvem, sem chaves de API e com total privacidade dos dados.
• Um export, todo o ecossistema: o mesmo .mlpackage funciona em iOS, iPadOS, macOS, watchOS, tvOS e visionOS, e alimenta o SDK para iOS e o plugin Flutter oficiais da Ultralytics.

Desempenho medido#

Inferência de ponta a ponta com uma única imagem para os recursos CoreML INT8 YOLO26n padronizados v8.3.0 em um iPhone 17 Pro com 12 GB de memória e iOS 26.5.2. O A19 Pro tem CPU de 6 núcleos (2 núcleos de desempenho e 4 de eficiência), GPU de 6 núcleos com aceleradores neurais e Neural Engine de 16 núcleos. Cada célula mostra o tempo total (pré-processamento + inferência + pós-processamento, sem incluir anotação), com a divisão por etapa abaixo. No iOS, o Vision redimensiona a entrada dentro da solicitação de inferência, por isso o pré-processamento aparece como 0 e seu custo está incluído na inferência.

• Os recursos de lançamento exatos 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 em rajada para uma única imagem — a média de 15 execuções após 3 execuções de aquecimento em bus.jpg, medidas pelo tempo por etapa do SDK para iOS, por meio do sistema de benchmark do plugin Flutter no modo de perfil (código nativo otimizado). A ordem entre CPU e acelerador foi alternada entre as tarefas em uma única sequência. As linhas de CPU solicitam Core ML .cpuOnly; as linhas CPU + ANE preferido solicitam .cpuAndNeuralEngine, e o Core ML controla a colocação final das operações. A operação sustentada da câmera em tempo real é mais lenta porque inclui o pipeline de captura e redimensionamento, além da estabilização térmica. Uma avaliação histórica da câmera anterior à padronização mediu 11.3 ms/quadro para detecção YOLO26n e 16.5 ms/quadro para profundidade YOLO26n no mesmo dispositivo — consulta o documento de desempenho do SDK para iOS para ver a criação de perfil em regime estável.
• Compara os resultados de CPU/GPU do Android na integração LiteRT e os resultados do NPU Snapdragon na integração Qualcomm QNN.

Tarefas suportadas#

O export CoreML é compatível com todas as sete tarefas da Ultralytics. A segmentação semântica e a estimativa de profundidade estão disponíveis apenas no 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 no primeiro export. O export é executado no macOS ou em Linux x86; para instruções detalhadas e práticas recomendadas, consulta o nosso guia de instalação e o guia de problemas comuns.

Uso#

O formato CoreML é compatível com os modos Export, Predict e Validate. A inferência e a validação com CoreML só são executadas no macOS. Exporta o teu modelo e, em seguida, carrega o modelo exportado para executar a inferência ou validar a precisão.

from ultralytics import YOLO

# Carrega um modelo YOLO26
model = YOLO("yolo26n.pt")

# Exportar para CoreML com quantização de pesos INT8, como nos modelos oficiais do app
model.export(format="coreml", quantize=8, imgsz=640)  # usar imgsz=224 para classificação

from ultralytics import YOLO

# Carregar o modelo CoreML exportado (macOS)
model = YOLO("yolo26n.mlpackage")

# Executar inferência
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carregar o modelo CoreML exportado (macOS)
model = YOLO("yolo26n.mlpackage")

# Validar a precisão no conjunto de dados COCO8
metrics = model.val(data="coco8.yaml")

Argumentos de exportação#

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

Usar o Neural Engine#

CoreML escolhe o hardware por meio de MLModelConfiguration.computeUnits. O SDK Ultralytics para iOS usa .cpuAndNeuralEngine por padrão no iOS 16+, em vez de .all: em uma aplicação de câmera em tempo real, a GPU já está ocupada compondo a pré-visualização e as sobreposições, então excluí-la evita contenção e oscilações no tempo dos quadros enquanto o ANE realiza o processamento pesado. Fixa .cpuOnly apenas para testes de compatibilidade — a tabela acima mostra o custo.

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

Implantar modelos YOLO26 CoreML exportados#

O caminho mais rápido é o SDK Ultralytics YOLO para iOS oficial, o mesmo pacote Swift que alimenta o app Ultralytics para iOS e o plugin Flutter. Ele resolve automaticamente os nomes oficiais dos modelos, 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 apps de câmera, adiciona o YOLOView do SDK para ter inferência em tempo real com sobreposições nativas ou usa o plugin Flutter para criar apps multiplataforma que compartilham uma única base de código com Android.

Também é simples integrar diretamente um .mlpackage bruto usando a pilha da Apple — carrega-o com MLModel, envolve-o em um VNCoreMLRequest e envia as imagens por meio de VNImageRequestHandler. Estes recursos explicam os detalhes:

• Integrar um modelo Core ML ao teu app: guia da Apple para incluir e chamar um modelo CoreML.
• Ferramentas CoreML: referência de conversão, quantização e otimização para o conjunto de ferramentas coremltools que alimenta este export.
• Relatórios de desempenho do Core ML no Xcode: criação de perfil da colocação de cada camada no dispositivo e da latência para o teu modelo e dispositivo específicos.

Inclui o modelo no pacote do app (disponibilidade imediata, ideal para modelos nano/pequenos) ou baixa-o na primeira execução e armazena-o em cache (binário menor e atualizações simples do modelo). Os apps oficiais combinam as duas abordagens: os modelos nano padrão são incluídos para uso imediato, enquanto as variantes maiores são baixadas 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 com os pesos oficiais do YOLO26
2. Exporta com model.export(format="coreml", quantize=8, imgsz=640) no macOS ou em Linux x86 (imgsz=224 para classificação)
3. Verifica a precisão com model.val() em um Mac e cria um perfil com um relatório de desempenho do Core ML do Xcode no dispositivo de destino
4. Implanta com o SDK para iOS, o plugin Flutter ou a tua própria integração com Vision, tendo como destino .cpuAndNeuralEngine

Resumo#

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

Perguntas frequentes#