Começar

Exportação Apple Core ML

Core ML é o framework da Apple para executar modelos de aprendizagem automática no iPhone, iPad, Mac, Apple Watch, Apple TV e Apple Vision Pro. Exportar um modelo Ultralytics YOLO26 com format="coreml" cria um pacote de modelo yolo26n.mlpackage que o Core ML executa na CPU, GPU e Apple Neural Engine, em FP32, FP16 ou com pesos de 8 bits.

Novo formato Core AI da Apple

A Apple apresentou o novo framework Core AI e o formato .aimodel para a geração iOS 27 e macOS 27, e a Ultralytics exporta neste formato com format="coreai". O Core ML continua a ser o formato predefinido dos SDKs Ultralytics para iOS e Flutter, que carregam o Core AI como opção nos dispositivos iOS 27, e o formato para sistemas operativos Apple anteriores.

Visão geral#

PropriedadeDetalhes
Argumento formatcoreml (aliases: mlpackage, mlprogram, apple, ios). mlmodel exporta o formato de rede neuronal anterior
Saídayolo26n.mlpackage, um pacote de modelo (um diretório) no formato ML Program, com os nomes das classes, a tarefa e o tamanho da imagem armazenados no seu interior como metadados
Funciona emiPhone, iPad, Mac, Apple Watch, Apple TV e Apple Vision Pro, na CPU, GPU e Apple Neural Engine
Ambiente de execuçãoCore ML, integrado nos sistemas operativos da Apple; o ML Program exportado declara a especificação Core ML 6 (iOS 15, macOS 12) ou, para INT8, a especificação 7 (iOS 16, macOS 13). Em Python, o pacote coremltools no macOS
PrecisãoFP32, FP16, INT8 (pesos de 8 bits). YOLO26n tem 9.9 MB em FP32, 5.1 MB em FP16 e 2.7 MB em INT8
Máquina de exportaçãomacOS ou Linux x86-64, com Python 3.13 ou anterior. Não Windows. A exportação não precisa de GPU
Exportar na nuvem

A Ultralytics Platform pode exportar um modelo treinado para Core ML por ti, sem precisares de um ambiente de exportação local.

Início rápido#

Instala o pacote Ultralytics com as dependências de exportação Core ML, no macOS ou no Linux x86-64:

pip install "ultralytics[export-coreml]"

Isto instala coremltools, scikit-learn e uma versão de numpy compatível com coremltools. Com um pip install ultralytics simples, a primeira exportação instala coremltools e, quando também tem de substituir uma versão mais recente de numpy, essa exportação falha; a seguinte é bem-sucedida. A exportação tem estes requisitos de versão:

PacoteVersão necessária
Python3.13 ou anterior, a versão mais recente para a qual coremltools 9.0 tem pacotes pré-compilados
coremltools9.0 ou posterior
numpy2.3.5 ou anterior. A exportação instala a versão 2.3.5 por cima de uma versão mais recente
torch1.11 ou posterior
scikit-learnApenas para quantize=8 e 'w8a16'. O extra export-coreml instala a versão 1.3.2 ou posterior, e a exportação instala-a se estiver em falta

Para outros métodos de instalação, consulta o guia de instalação. Em seguida, exporta o teu modelo e carrega o pacote exportado para executar inferências ou validar a sua precisão.

Exportar
from ultralytics import YOLO

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

# Exporta o modelo para o formato Core ML
model.export(format="coreml")  # cria 'yolo26n.mlpackage'

# Ou exporta em FP16, o que reduz o tamanho para metade e permite executar o modelo na Neural Engine
model.export(format="coreml", quantize=16)  # cria 'yolo26n.mlpackage'

Ambas as exportações escrevem o mesmo yolo26n.mlpackage, por isso a segunda substitui a primeira. Predict e Validate só são executados no macOS:

Prever
from ultralytics import YOLO

# Carrega o modelo Core ML exportado num Mac
model = YOLO("yolo26n.mlpackage")

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

# Carrega o modelo Core ML exportado num Mac
model = YOLO("yolo26n.mlpackage")

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

Tarefas suportadas#

A exportação Core ML suporta todas as sete tarefas Ultralytics com modelos YOLOv8, YOLO11 e YOLO26: deteção, segmentação, segmentação semântica, estimativa de profundidade, classificação, estimativa de pose e OBB. A segmentação semântica e a estimativa de profundidade só estão disponíveis com YOLO26, a única família que inclui essas cabeças. Também é possível exportar modelos de deteção YOLOv5u, YOLOv9, YOLOv10 e YOLO12, assim como modelos RT-DETR e YOLO-Worldv2. Cada modelo foi testado com um checkpoint por tarefa, por exemplo yolo11n-seg.pt, rtdetr-l.pt e yolov8s-worldv2.pt.

Argumentos de exportação#

ArgumentoTipoPadrãoDescrição
formatstr'coreml'Formato de destino do modelo exportado, que define a compatibilidade com vários ambientes de implantação.
imgszint ou tuple640Tamanho da imagem de entrada do modelo, fixo numa exportação predefinida: um número inteiro para imagens quadradas ou um tuplo (height, width). Se não for indicado, a exportação usa o tamanho com que o checkpoint foi treinado. Os checkpoints oficiais YOLO26 usam 640 para modelos de deteção, segmentação e pose, e para modelos semânticos pré-treinados em ADE20K; 1024 para modelos OBB e modelos semânticos pré-treinados em Cityscapes; 768 para profundidade; e 224 para classificação.
quantizeint ou strNonePrecisão: 16 (FP16) ou 8 (pesos de 8 bits com cálculo FP16; 'w8a16' é a mesma exportação); 32/não definido corresponde a FP32. Com nms=True, o valor não definido corresponde a FP16. Não é possível exportar para Core ML um checkpoint treinado com quantize=8; consulta Limitações e resolução de problemas. Substitui as flags obsoletas half/int8.
nmsbool, opcionalNoneSeleciona a saída em bruto (None, predefinição), NMS integrado (True, para modelos de deteção, segmentação e pose com dynamic=False) ou a cabeça sem NMS (False). Consulta o formato de saída.
conffloatNoneLimiar de confiança armazenado numa exportação nms=True. Usa 0.25 se não for definido.
ioufloat0.5Limiar IoU armazenado numa exportação nms=True.
agnostic_nmsboolFalseSeleção independente da classe: numa exportação nms=True, uma caixa também suprime caixas sobrepostas de outras classes. Também altera a seleção das linhas de uma exportação nms=False.
max_detint300Número de linhas na saída de uma exportação nms=False e de uma exportação de segmentação ou pose nms=True. Uma exportação de deteção nms=True não tem esse limite.
dynamicboolFalseTorna dinâmicos o tamanho do lote, a altura e a largura da entrada, e altera a entrada de uma imagem para um array. Não está disponível para modelos de classificação e RT-DETR nem com nms=True. Consulta Implementação.
batchint1Maior tamanho de lote de uma exportação dynamic=True. Uma exportação predefinida tem tamanho de lote 1; outros valores geram um erro.
devicestrNoneDispositivo usado para rastrear o modelo durante a conversão, cpu por predefinição. Uma exportação FP32 rastreada com mps teve o mesmo tamanho de pacote e devolveu as mesmas saídas que uma rastreada na CPU.

Para consultar os argumentos compartilhados por todos os formatos, veja a documentação do modo de exportação.

Tamanho da imagem e definições dos modelos móveis oficiais

Os modelos móveis oficiais Core ML, LiteRT e QNN são exportados em imgsz=640 e, para classificação, em imgsz=224. Os checkpoints semânticos Cityscapes, de profundidade e OBB são exportados por predefinição com um tamanho maior, por isso indica imgsz=640 para os igualar. Os modelos Core ML do SDK Ultralytics para iOS são exportados com quantize=8 nms=False.

Precisão#

quantize seleciona como os pesos são armazenados e a precisão usada nos cálculos do Core ML. Nenhuma das três precisões requer dados de calibração. Os tamanhos correspondem a um modelo de deteção YOLO26n exportado em imgsz=640:

quantizePesosCálculoSO mínimoTamanho do YOLO26n
omitido ou 32FP32FP32iOS 15, macOS 129.9 MB
16FP16FP16iOS 15, macOS 125.1 MB
8 ou 'w8a16'8 bitsFP16iOS 16, macOS 132.7 MB
  • FP32: a predefinição quando nms=True não está definido. Num Apple M4, as exportações FP32 das sete tarefas devolveram as mesmas saídas com as unidades de cálculo CPU_AND_NE, usadas pela Ultralytics, e com CPU_ONLY, e não foram mais rápidas com as primeiras. Exporta em FP16 ou INT8 para usar a Neural Engine. Num iPhone 17 Pro, um modelo de deteção YOLO26n FP32 foi no máximo 5% mais rápido com a Neural Engine, considerando a mediana de três execuções; consulta Desempenho medido.
  • FP16: quantize=16 armazena os pesos e efetua os cálculos em precisão reduzida. A entrada de imagem e os arrays de saída mantêm os tipos da exportação FP32 (float32 ou int32 para segmentação semântica), pelo que o código de inferência escrito para o modelo FP32 é executado sem alterações.
  • INT8: quantize=8 e quantize="w8a16" são a mesma exportação. Agrupa os pesos de cada camada em grupos de 256 valores usando k-means e armazena um índice de 8 bits para cada peso (paletização), efetuando os cálculos em FP16, tal como numa exportação FP16. Os tensores de pesos com 512 valores ou menos não são paletizados. Trata-se de compressão de pesos, não de quantização calibrada de ativações, que quantize=8 seleciona para outros formatos; por isso, não aceita o argumento data. Com scikit-learn já instalado, a exportação de um modelo de deteção YOLO26n demorou 18 a 26 s num Apple M4 e 23 a 24 s num servidor x86-64; a exportação de YOLO26x demorou 104 s nesse servidor.
  • Precisão: consulta as tabelas Apple M4 para ver os resultados COCO em cada precisão. Valida um modelo exportado com os teus próprios dados antes de o implementar.

Formato de saída#

A exportação escreve um pacote, um diretório que Xcode, Core ML e coremltools abrem como um único modelo:

Ficheiro em yolo26n.mlpackage/Conteúdo
Manifest.jsonA lista de ficheiros no pacote
Data/com.apple.CoreML/model.mlmodelO grafo da rede, as descrições de entrada e saída e os metadados: nomes das classes, tarefa, tamanho da imagem, tamanho do lote, stride e argumentos de exportação, que a Ultralytics lê ao carregar o modelo
Data/com.apple.CoreML/weights/weight.binOs pesos

O modelo recebe uma entrada chamada image. Numa exportação predefinida, é uma entrada de imagem Core ML: uma imagem RGB do tipo imgsz exportado, com valores de píxel entre 0 e 255. A divisão por 255 faz parte do modelo, por isso não redimensiones a escala da imagem; numa aplicação, o framework Vision da Apple pode redimensionar um fotograma da câmara para esta entrada. Uma exportação com dynamic=True recebe, em vez disso, um array float32 com a forma (batch, 3, height, width), em RGB e com valores entre 0 e 1.

Os nomes dos arrays de saída são gerados pelo conversor, como var_1401, e variam entre modelos e definições de exportação; por isso, lê-os na descrição do modelo em vez de os codificares diretamente. O argumento nms e a tarefa determinam as saídas. As formas abaixo correspondem aos checkpoints oficiais YOLO26n com o tamanho de exportação predefinido, usando o checkpoint Cityscapes yolo26n-sem.pt para segmentação semântica:

Tarefaimgsz padrãoSaída com nms=NoneSaída com nms=FalseSaída com nms=True
Detecção640(1, 84, 8400)(1, 300, 6)confidence (boxes, 80) e coordinates (boxes, 4)
Segmentação640(1, 116, 8400) e (1, 32, 160, 160)(1, 300, 38) e (1, 32, 160, 160)(1, 300, 38) e (1, 32, 160, 160)
Semântica1024(1, 1024, 1024), índice da classe de cada píxelIgual a nms=NoneIgual a nms=None
Profundidade768(1, 1, 768, 768), mapa de profundidadeIgual a nms=NoneIgual a nms=None
Classificação224classLabel e classLabel_probsIgual a nms=NoneIgual a nms=None
Pose640(1, 56, 8400)(1, 300, 57): 6 valores da caixa, seguidos de 17 pontos-chave x 3(1, 300, 57)
OBB1024(1, 20, 21504)(1, 300, 7): 4 valores da caixa, pontuação, classe, ânguloIgual a nms=None
  • Saída em bruto (nms=None): forma (1, values, anchors), as mesmas previsões em bruto de uma exportação ONNX predefinida: para cada âncora, o centro x e o centro y da caixa, a largura e a altura em píxeis da entrada, seguidos das pontuações das classes e dos valores da tarefa (32 coeficientes de máscara, 17 x 3 valores de pontos-chave ou o ângulo OBB em radianos). Aplica o NMS por tua conta.
  • Saída sem NMS (nms=False): max_det (predefinição 300) linhas de x1, y1, x2, y2, score, class em píxeis da entrada, sem etapa NMS. As linhas OBB são center x, center y, width, height, score, class, angle. Filtra as linhas pela pontuação. Disponível para modelos com uma cabeça sem NMS, como YOLO26 e YOLOv10.
  • NMS integrado para deteção (nms=True): o pacote é um pipeline Core ML que combina o modelo com a etapa NMS da Apple. Devolve confidence, uma linha de pontuações de classes para cada caixa mantida, e coordinates, o centro x e o centro y da caixa, a largura e a altura de cada caixa mantida em relação ao tamanho da imagem (0-1). O número de linhas varia de imagem para imagem. conf (predefinição 0.25), iou (predefinição 0.5) e agnostic_nms são armazenados no pipeline durante a exportação; as entradas confidenceThreshold e iouThreshold, que podem ser omitidas, substituem os dois limiares numa previsão. max_det não tem efeito: uma exportação com max_det=2 ainda devolveu cinco caixas para uma imagem de teste. Para um modelo cujo número de classes não seja múltiplo de 80, a exportação preenche confidence com colunas adicionais até ao múltiplo de 80 seguinte.
  • NMS integrado para segmentação e pose (nms=True): o NMS é executado dentro do grafo do modelo, que devolve max_det linhas de x1, y1, x2, y2, score, class, seguidas dos coeficientes de máscara ou dos pontos-chave. As linhas posteriores à última deteção têm pontuação 0; por isso, filtra as linhas pela pontuação. conf, iou, agnostic_nms e max_det são fixados durante a exportação, e estas exportações são sempre FP16 ou INT8.
  • Segmentação: a saída 3D contém as previsões e a saída 4D contém os protótipos de máscara.
  • Segmentação semântica: a saída é o índice da classe de cada píxel como int32, não uma pontuação para cada classe.
  • Classificação: o pacote é um classificador Core ML que devolve classLabel, o nome da classe com a pontuação mais alta, e classLabel_probs, um dicionário de nomes de classes e probabilidades. coremltools também devolve as probabilidades num array (1, classes).

YOLO("yolo26n.mlpackage") lê a disposição dos dados a partir dos metadados do modelo; por isso, só precisas destes detalhes se executares o modelo no teu próprio código. Os metadados são armazenados como cadeias nos metadados definidos pelo utilizador do modelo. As respetivas chaves incluem names, task, imgsz, stride, batch, end2end, args e, para modelos de pose, kpt_shape.

Executar com coremltools#

Para executar o pacote num Mac fora do pacote Ultralytics, carrega-o com coremltools, que também seleciona as unidades de cálculo:

# Exporta primeiro: yolo export model=yolo26n.pt format=coreml quantize=16 nms=False
import ast

import coremltools as ct
import numpy as np
from PIL import Image

model = ct.models.MLModel("yolo26n.mlpackage", compute_units=ct.ComputeUnit.CPU_AND_NE)

image = Image.fromarray(np.zeros((640, 640, 3), dtype=np.uint8))  # a tua imagem com letterbox: RGB, 0-255
outputs = model.predict({"image": image})
detections = next(iter(outputs.values()))[0]  # o único array de saída, primeira imagem: forma (300, 6)
assert detections.shape == (300, 6), "export a detection model at imgsz=640 with nms=False"
detections = detections[detections[:, 4] > 0.25]  # manter as linhas acima do limiar de confiança

names = ast.literal_eval(model.user_defined_metadata["names"])  # {0: 'person', 1: 'bicycle', ...}

Implantar#

Num iPhone ou iPad, adiciona o .mlpackage ao teu projeto Xcode ou usa o SDK Ultralytics para iOS, que o carrega e descodifica as saídas por ti. Num Mac, instala o pacote com pip install ultralytics e copia para lá o .mlpackage: YOLO("yolo26n.mlpackage") executa o modelo com coremltools, que a Ultralytics instala na primeira utilização.

  • Unidades de cálculo: a Ultralytics carrega um modelo com as unidades de cálculo Core ML CPU_AND_NE, a CPU e a Neural Engine, e os modelos RT-DETR com ALL. Se o modelo não carregar com essas unidades, carrega-o com CPU_ONLY. Não existe um argumento para escolher outras unidades de cálculo; carrega o pacote com coremltools para o fazer. Num Apple M4 com macOS 27.2, ALL e CPU_AND_GPU também executaram os modelos FP32, FP16 e INT8 das sete tarefas YOLO26n; outras versões do macOS não foram testadas.
  • device: o argumento device não seleciona o hardware Core ML. Com device="mps", a Ultralytics pré-processa e pós-processa na GPU Apple, enquanto o Core ML continua a usar as mesmas unidades de cálculo. Num M4, isto não acelerou a inferência: um modelo YOLO26n FP16 demorou cerca de 8 ms por imagem com device="mps", contra cerca de 6 ms sem ele; por isso, deixa device sem definir.
  • Precisão e Neural Engine: num Apple M4, a etapa de inferência de YOLO() demorou 18 a 20 ms por imagem em predict para um modelo YOLO26n FP32 (21.0 ms na validação COCO em Apple M4) e cerca de 6 ms para os modelos FP16 e INT8, em exportações predefinidas (nms=None) e numa imagem de teste com macOS 27.2. Apenas com coremltools, os mesmos modelos FP16 e INT8 demoraram cerca de 2 ms com CPU_AND_NE, contra 9 a 10 ms com CPU_ONLY.
  • Forma de entrada fixa: uma exportação predefinida é sempre executada com o imgsz da exportação, que a Ultralytics lê nos metadados do modelo. Um imgsz passado a predict ou val é ignorado. A Ultralytics envia cada imagem de um lote para o Core ML como um pedido separado de imagem única; por isso, é possível usar qualquer número de imagens, e val define batch=1.
  • Exportação dinâmica (dynamic=True): o modelo declara tamanhos de lote de 1 até batch da exportação e tamanhos de imagem de 32 píxeis até ao dobro de imgsz da exportação; a Ultralytics passa tamanhos de imagem em múltiplos do stride do modelo. A Ultralytics divide os lotes maiores em blocos de batch da exportação. Com a cabeça sem NMS, o tamanho mínimo é maior: 128 píxeis para um modelo YOLO26n exportado em imgsz=640 com nms=False. Testado com um modelo de deteção a 320, 640 e 1280 píxeis e com um modelo de segmentação a 640.

SDK Ultralytics para iOS e plugin Flutter#

O SDK Ultralytics para iOS é um pacote Swift que carrega exportações Core ML das sete tarefas YOLO26 e devolve resultados descodificados. Exporta com as definições dos modelos oficiais da aplicação:

# INT8 weights and the NMS-free head; use imgsz=224 for classification models
yolo export model=yolo26n.pt format=coreml quantize=8 nms=False imgsz=640

Adiciona https://github.com/ultralytics/yolo-ios-app.git à tua aplicação com o Swift Package Manager e, em seguida, carrega o pacote exportado:

import UltralyticsYOLO

// Load your exported Core ML model, then run inference on a UIImage
let yolo = YOLO("/path/to/yolo26n.mlpackage", task: .detect) { result in
    if case .success(let model) = result {
        let results = model(uiImage)  // boxes, labels, confidences, timing
    }
}

O SDK executa modelos Core ML através de VNCoreMLRequest do Vision, que redimensiona cada imagem para a entrada do modelo. Para aplicações de câmara, YOLOView do SDK executa inferências em tempo real com sobreposições nativas, e o plugin Ultralytics YOLO para Flutter executa as mesmas exportações Core ML no iOS a partir de uma base de código partilhada com Android. No iOS 16 e posterior, o SDK pede .cpuAndNeuralEngine ao Core ML em vez de .all, porque numa aplicação de câmara a GPU já está ocupada com a pré-visualização e as sobreposições.

Guias de implantação#

Limitações e solução de problemas#

  • Primeira exportação após uma instalação simples: quando a primeira exportação tem de substituir numpy (as versões posteriores à 2.3.5 impedem a conversão), a Ultralytics regista Restart runtime or rerun command for updates to take effect e essa exportação falha com TypeError: only 0-dimensional arrays can be converted to Python scalars. Volta a executar a exportação num novo processo, o que implica reiniciar o kernel num notebook, ou instala "ultralytics[export-coreml]" antes da primeira exportação, como indicado no Guia de início rápido.
  • Sistema anfitrião da exportação: a exportação é executada em macOS e Linux x86-64. Não é suportada em Windows nem em Linux ARM64, como num Raspberry Pi: coremltools 9.0 publica pacotes pré-compilados apenas para macOS e Linux x86-64.
  • Versão de Python: coremltools 9.0 tem pacotes pré-compilados para Python 3.13 e versões anteriores. Em Python 3.14, pip install "ultralytics[export-coreml]" não instala nenhum dos pacotes Core ML, pelo que a exportação compila coremltools a partir do código-fonte. A primeira exportação falha, tal como após uma instalação simples, e a seguinte é executada com RuntimeError: BlobWriter not loaded. Cria o ambiente com Python 3.13 ou anterior.
  • A inferência requer macOS: no Linux, a previsão ou validação com YOLO("yolo26n.mlpackage") falha com Model prediction is only supported on macOS version 10.13 or later.. Valida o checkpoint PyTorch nesse sistema ou copia o pacote para um Mac.
  • Instalação automática desativada: com YOLO_AUTOINSTALL=false, a exportação falha com No module named 'coremltools' num ambiente sem o pacote.
  • Checkpoints treinados com quantize=8: um checkpoint ajustado com treino com reconhecimento da quantização falha com format='coreml' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends. Em vez disso, exporta o checkpoint usado como ponto de partida do ajuste fino com quantize=8, ou exporta o checkpoint ajustado para ONNX ou TensorRT.
  • quantize="w8a32": falha com quantize='w8a32' is not supported; format='coreml' supports quantize=16 (FP16), 8 (INT8), 'w8a16' (INT8 weights + INT16 activations), 32 or None (FP32).. Para Core ML, 'w8a16' é a mesma exportação que 8, com cálculo FP16.
  • NMS integrado noutras tarefas: nms=True funciona com modelos de deteção, segmentação e pose. Para modelos OBB e de classificação, a exportação regista CoreML 'nms=True' is only supported for detect, segment and pose models. Forcing 'nms=None'.; para modelos de segmentação semântica e estimativa de profundidade, 'nms=True' is not valid for semantic models. Forcing 'nms=None'. (ou depth models); e para modelos RT-DETR, 'nms=True' is not available for end2end models or non-YOLO heads. Forcing 'nms=None'.. Todos produzem a saída de uma exportação predefinida.
  • Precisão do NMS integrado: uma exportação nms=True sem quantize é FP16. quantize=32 produz um pipeline FP32 para um modelo de deteção; para modelos de segmentação e pose, a exportação regista CoreML 'nms=True' requires FP16 for segment models. Forcing 'quantize=16'. (ou pose models).
  • NMS integrado e validação: uma exportação nms=True remove as caixas abaixo de conf antes de val as processar; por isso, obtém uma pontuação inferior à do mesmo modelo com NMS externo: no COCO val2017, uma exportação FP16 YOLO26n com nms=True obteve 33.8 mAPval 50-95 com o conf=0.25 predefinido e 39.9 quando exportada com conf=0.001, ainda 1.0 abaixo dos 40.9 de uma exportação FP16 predefinida. Exporta com conf=0.001 para validar esse modelo e escolhe separadamente o limiar de implementação.
  • Cabeça sem NMS noutros modelos: nms=False precisa de um modelo com uma cabeça sem NMS, como YOLO26 ou YOLOv10. Noutros modelos, por exemplo YOLO11, a exportação apresenta o aviso This model has no one-to-one head; using one-to-many outputs. e grava a saída em bruto (1, 84, 8400).
  • Tamanho do lote: um batch superior a 1 sem dynamic=True falha com batch sizes > 1 are not supported without 'dynamic=True' for CoreML export. Please retry at 'dynamic=True'..
  • Formas dinâmicas: dynamic=True sem batch regista 'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'. e exporta um modelo com tamanho máximo de lote 1. Com nms=True, falha com 'nms=True' cannot be used together with 'dynamic=True' for CoreML export. Please disable one of them.; para modelos de classificação e RT-DETR, falha com 'dynamic=True' is not supported for CoreML classification or RT-DETR models.. Um tamanho de imagem fora do intervalo provoca um erro durante a previsão, como Size (1312) of dimension (2) is not in allowed range (32..1280).
  • Segmentação semântica na Neural Engine: num Apple M4, um modelo YOLO26n-sem demorou mais com CPU_AND_NE do que com CPU_ONLY, usando apenas coremltools numa imagem de teste: 59 a 64 ms, contra 22 ms para a exportação FP16 em imgsz=1024, e cerca de 15 ms, contra 9 ms, para a exportação INT8 em imgsz=640. Os modelos FP16 das outras seis tarefas e os respetivos modelos INT8 em imgsz=640 (224 para classificação) foram executados mais rapidamente com CPU_AND_NE; no iPhone 17 Pro, o modelo semântico INT8 também foi mais rápido com a Neural Engine. YOLO() usa sempre CPU_AND_NE para estes modelos; por isso, mede um modelo semântico com ambas as definições no teu próprio código.
  • .cpuOnly no iOS 27.0.1: num iPhone 17 Pro, a inferência .cpuOnly dos modelos de profundidade, pose e OBB YOLO26l e YOLO26x bloqueou dentro dos kernels da CPU do Core ML (EXC_BAD_ACCESS em libBNNS). Os modelos são executados com .cpuAndNeuralEngine, que o SDK para iOS solicita.
  • Nome do pacote: cada exportação de um checkpoint grava o mesmo yolo26n.mlpackage, independentemente de quantize, imgsz, nms ou dynamic; por isso, a exportação posterior substitui a anterior. Muda o nome do pacote para manter ambos e conserva o sufixo .mlpackage, por exemplo yolo26n_fp16.mlpackage, porque a Ultralytics identifica o formato por esse sufixo. Um pacote sem o sufixo falha com is not a supported model format.
  • Aviso sobre a versão do PyTorch: com uma versão recente do PyTorch, coremltools regista Torch version 2.15.0 has not been tested with coremltools. You may run into unexpected errors. ao carregar; com uma versão recente de scikit-learn, regista scikit-learn version 1.9.1 is not supported.. As exportações e os resultados no Mac nesta página foram obtidos com estas versões.
  • Ficheiros .mlmodel antigos: format="mlmodel" exporta o formato anterior de rede neuronal Core ML como um único ficheiro yolo26n.mlmodel, para aplicações que não conseguem carregar um ML Program. Nesse formato, quantize=8 e 'w8a16' aplicam quantização linear de pesos de 8 bits. Usa o .mlpackage predefinido em projetos novos.

Para outros erros, consulte o guia de problemas comuns.

Desempenho medido#

As tabelas abaixo foram medidas num iPhone 17 Pro e num Mac Apple M4. A página do modelo YOLO26 apresenta a precisão dos checkpoints PyTorch para cada tarefa.

iPhone 17 Pro#

Hardware: iPhone 17 Pro com iOS 26.6. O A19 Pro tem uma CPU de 6 núcleos (2 de desempenho e 4 de eficiência), uma GPU de 6 núcleos e um Neural Engine de 16 núcleos.

A primeira tabela mostra a latência de uma imagem para o modelo INT8 oficial de cada tarefa, os recursos v8.3.0 do Ultralytics iOS SDK, exportados com nms=False. Cada célula apresenta o tempo total em milissegundos, com a divisão entre pré-processamento / inferência / pós-processamento abaixo; a unidade de computação mais rápida aparece em negrito:

ModeloTarefatamanho
(pixels)
CPU
Core ML .cpuOnly
(ms)
CPU + Neural Engine
Core ML .cpuAndNeuralEngine
(ms)
YOLO26nDetecção6409.7
0.0 / 9.7 / 0.0
4.7
0.0 / 4.7 / 0.0
YOLO26n-segSegmentação64012.8
0.0 / 12.2 / 0.6
5.8
0.0 / 5.0 / 0.7
YOLO26n-semSemântica6409.3
0.0 / 8.9 / 0.5
5.3
0.0 / 4.8 / 0.5
YOLO26n-depthProfundidade64025.8
0.0 / 24.8 / 1.0
8.0
0.0 / 6.9 / 1.1
YOLO26n-clsClassificação2242.1
0.0 / 2.0 / 0.0
1.8
0.0 / 1.8 / 0.0
YOLO26n-posePose64011.9
0.0 / 11.9 / 0.0
5.4
0.0 / 5.4 / 0.0
YOLO26n-obbOBB64010.6
0.0 / 10.6 / 0.0
4.9
0.0 / 4.9 / 0.0

A mesma medição para os cinco modelos de deteção, incluindo o tempo que o SDK demora a carregar cada modelo:

ModeloCPU
.cpuOnly
(ms)
CPU + Neural Engine
.cpuAndNeuralEngine
(ms)
Carregamento do modelo
.cpuAndNeuralEngine
(s)
YOLO26n9.24.50.9
YOLO26s19.510.51.3
YOLO26m46.711.81.8
YOLO26l60.112.02.4
YOLO26x125.920.53.3

Deteção com YOLO26n nas três precisões e com duas configurações nms, exportadas com ultralytics 8.4.215 em imgsz=640; o tempo total em milissegundos:

Precisãonms=None, CPUnms=None, CPU + Neural Enginenms=False, CPUnms=False, CPU + Neural Engine
FP3215.514.714.514.4
FP169.24.99.25.0
INT89.24.29.15.0
  • Método: média de 15 previsões após 3 previsões de aquecimento em bus.jpg, através do SDK Swift 8.9.23 numa compilação de lançamento. .cpuOnly e .cpuAndNeuralEngine são as unidades de computação Core ML solicitadas pelo SDK; o Core ML decide onde cada camada é executada. Cada tabela foi medida em três execuções separadas e apresenta a mediana. As três execuções concordaram dentro de 15%, exceto no YOLO26n com .cpuAndNeuralEngine, que demorou de 2.6 a 4.8 ms na tabela de tamanhos e de 3.8 a 4.8 ms na exportação INT8 nms=None. As tabelas de tarefas e tamanhos usam os recursos oficiais v8.3.0, e a tabela de precisão usa exportações feitas com ultralytics 8.4.215, por isso os valores do YOLO26n diferem, até 0.5 ms com o Neural Engine e 0.6 ms na CPU.
  • Pré-processamento: o Vision redimensiona a imagem dentro do pedido de inferência, por isso o pré-processamento é indicado como 0 e o seu custo faz parte da inferência.
  • FP32: de acordo com estas medianas, a exportação FP32 foi no máximo 5% mais rápida com .cpuAndNeuralEngine do que com .cpuOnly, enquanto FP16 e INT8 foram cerca de duas vezes mais rápidas. Exporta em FP16 ou INT8 para usar o Neural Engine.
  • nms: na deteção com YOLO26n, a cabeça sem NMS (nms=False) e a saída bruta com NMS no SDK (nms=None) demoraram ambas 4 a 5 ms com o Neural Engine em FP16 e INT8.
  • Apps de câmara: estas são latências de uma única imagem. Um app de câmara em tempo real acrescenta o tempo de captura e apresentação; consulta as notas de desempenho do iOS SDK.
  • Compara os resultados de CPU/GPU no LiteRT integration, os resultados de MediaTek Dimensity e os resultados de NPU Snapdragon na integração Qualcomm QNN.

Apple M4#

As tabelas abaixo comparam PyTorch com modelos Core ML FP32, FP16 e INT8 de cada modelo de deteção YOLO26 num Apple M4 (4 núcleos de desempenho e 6 de eficiência) com macOS 27.2, validados através de YOLO() no COCO val2017. O PyTorch foi executado na CPU com 8 threads, batch=1 e rect=False, para receber a mesma entrada de 640x640 que os modelos Core ML, executados com as unidades de computação predefinidas do Ultralytics.

Milissegundos por imagem; quanto menor, melhor. O formato mais rápido para cada modelo está em negrito.

ModeloimgszPyTorchCore ML FP32Core ML FP16Core ML INT8
YOLO26n64025.621.06.06.0
YOLO26s64060.050.07.97.6
YOLO26m640137.2127.614.311.3
YOLO26l640191.2187.717.213.5
YOLO26x640341.1334.228.624.3

Com a cabeça sem NMS (nms=False), YOLO26n atingiu 40.3 mAPval 50-95 em PyTorch e FP32, 40.2 em FP16 e 40.1 em INT8.

A latência do YOLO26n com cada unidade de computação Core ML, medida apenas com coremltools como a mediana de 20 previsões numa imagem, em milissegundos:

PrecisãoCPU_ONLYCPU_AND_NEALLCPU_AND_GPU
FP3213.713.68.38.0
FP169.61.82.07.7
INT89.41.81.88.1
  • FP16 e INT8 foram 3.5 a 14 vezes mais rápidos do que FP32 através de YOLO(), com uma precisão a até 0.1 mAP de FP32 para FP16 e até 0.2 para INT8. INT8 foi tão rápido como FP16 para YOLO26n e até 1.3 vezes mais rápido para os modelos maiores.
  • FP32 produziu as mesmas saídas com CPU_AND_NE e com CPU_ONLY. Apenas as unidades de computação da GPU o tornaram mais rápido.
  • INT8 tornou o pacote 3.7 a 4.0 vezes mais pequeno do que FP32.

Medido com ultralytics 8.4.215, coremltools 9.0 e PyTorch 2.15.0 em batch=1, a 17 de novembro de 2026. A latência corresponde à etapa de inferência indicada por val e não inclui o pré-processamento nem o pós-processamento. Uma segunda execução dos três casos Core ML do YOLO26n no mesmo dia apresentou uma diferença de até 2.3 ms: 21.0 contra 18.8 ms para FP32.

Sobre o Core ML#

O Core ML está integrado no iOS, iPadOS, macOS, watchOS, tvOS e visionOS. Carrega modelos no formato ML Program, o formato .mlpackage gerado por esta exportação, e executa cada camada na CPU, na GPU ou no Apple Neural Engine, o NPU do silício da Apple, para que a inferência funcione offline e os dados permaneçam no dispositivo. Para a referência completa, consulta a documentação do Core ML.

Apple Core ML deployment pipeline



Assista: Como exportar Ultralytics YOLO26 para CoreML com quantização INT8 | Implantação Apple | iOS/MacOS 🍎

Perguntas frequentes#

  • Ambos são executados no Neural Engine e fazem cálculos em FP16, por isso a escolha depende do tamanho. FP16 (quantize=16) reduz o pacote para metade: 5.1 MB contra 9.9 MB para YOLO26n; INT8 (quantize=8) armazena pesos de 8 bits, ocupa 2.7 MB para YOLO26n e é a precisão dos modelos oficiais do app Ultralytics. No COCO val2017, uma exportação predefinida do YOLO26n atingiu 40.9 mAPval 50-95 em FP16 e 40.8 em INT8 num Apple M4, e ambos demoraram aproximadamente o mesmo tempo por imagem. Num iPhone 17 Pro, ambos demoraram 4 a 5 ms para YOLO26n com o Neural Engine, dentro da variação entre execuções. INT8 requer iOS 16 ou macOS 13, enquanto FP16 também funciona no iOS 15 e macOS 12. Nenhum dos dois requer dados de calibração. Evita a exportação predefinida FP32 para implementação: é a maior e, nos nossos testes, foi no máximo 5% mais rápida com as unidades de computação do Neural Engine do que apenas na CPU; consulta Precisão. Valida o modelo exportado com os teus próprios dados e dispositivo antes de o disponibilizares.

  • Depende de quem descodifica a saída. Com o Ultralytics iOS SDK ou o plugin Flutter, exporta os modelos YOLO26 com nms=False, tal como os modelos oficiais: o SDK lê então as deteções finais da cabeça sem NMS e não precisa de uma etapa NMS. No COCO val2017, YOLO26n em INT8 atingiu 40.1 mAPval 50-95 com a cabeça sem NMS, contra 40.8 com a saída predefinida e NMS externa. Num iPhone 17 Pro, ambos demoraram 4 a 5 ms por imagem. Com a framework Vision da Apple e o teu próprio código, nms=True converte um modelo de deteção numa pipeline Core ML com a etapa NMS da Apple, cujos limiares podes alterar para cada previsão. O Vision devolve as deteções como objetos VNRecognizedObjectObservation, e a pontuação de uma caixa é o confidence da observação. Não carregues um modelo de deteção nms=True com o SDK: num teste num iPhone 17 Pro com iOS 26.6, o SDK 8.9.23 apresentou cerca de 1.0, a confiança do rótulo com maior pontuação de cada caixa, em vez das pontuações das caixas. A configuração predefinida nms=None devolve previsões brutas e deixa o NMS a cargo do teu código. Consulta Formato de saída para ver as saídas de cada configuração.

  • Podes exportar sem um: a exportação é executada em Linux x86-64, e a Ultralytics Platform exporta na nuvem. Para executar o modelo, precisas de hardware Apple, porque o Core ML faz parte dos sistemas operativos da Apple. Em Linux e Windows, valida o checkpoint PyTorch ou uma exportação ONNX desse checkpoint; depois, valida o próprio modelo Core ML num Mac, onde YOLO("yolo26n.mlpackage").val() o executa, ou no dispositivo.

Comentários13

Faz uma pergunta, partilha os teus resultados ou ajuda alguém.

  1. Afool4UGitHub

    Hello! I have trouble when I tried to export yolo11n.pt to coreml model with tracking. for example, the exist tracking method is like this:

    # use YOLO tracking
    results = yolo_model.track(frame, persist=True, verbose=False)

    And I've export pt format and reloaded the new coreml format model like this:

    model.export(format='coreml', nms=True, half=False)
    model = ct.models.MLModel('yolo11n.mlpackage')

    But when I tried to make a tracking on my camera stream, it seems that object 'model' have no attribute named 'track'. So how could I use tracking by a coreml format model? It's very important to me because the coreml model works well on my macbook.

  2. SebastianxhjGitHub

    I used the example python code you guys gave. Why does output output confidence and coordination after converting my target detection model to mlpackage format. is it normal to not return processed images? Or is there something wrong with my export process.

    1. Glenn JocherUltralytics

      @taeja7 the CoreML export returns raw detection outputs (confidence, coordinates) rather than processed images by design. This is normal behavior, as post-processing like bounding box rendering is typically handled within the application layer after inference. For implementation guidance, see the CoreML deployment documentation on handling model outputs in Apple apps.

  3. smadsenjcGitHub

    I have a trained model that is doing very well in Python, but once I convert it to CoreML .mlpackage format and run inference in Swift, the results are garbage on the same images.

    If I export with nms=True, I get multiple overlapping bounding boxes back, similar-ish to when no NMS is done. The number of clusters matches the objects I expect, and they're kind of relatively positioned correctly, although the boxes themselves are too large and clustered in the wrong location. The predicted labels are right.

    If I export with nms=False, I get a different result back from VNCoreMLRequest: a single VNCoreMLFeatureValueObservation instead of an array of VNRecognizedObjectObservation.

    I've used both coremltools 8.0 and 8.2. If I run inference in Python using the CoreML model, it's fine (with nms=False; True fails).

    This was working back in November, but I got side-tracked with other work. I haven't touched the model.

    1. Glenn JocherUltralytics

      @smadsenjc for CoreML inference discrepancies between Python and Swift, ensure you're handling NMS parameters correctly in your Swift implementation. The CoreML export with nms=True requires explicit IOU and confidence threshold inputs during inference - these must match your Python training parameters. We recommend verifying your Swift preprocessing matches Ultralytics' RGB channel ordering and normalization (scale=1/255, bias=[0,0,0]). For direct assistance with Apple's Vision framework implementation, refer to Apple's CoreML integration guide linked in our documentation.

  4. CharanPrasadKGitHub

    When I am Converting the Yolo .pt model to coreml model , mlpackage is creating and when I am checking it in the xcode the class labels are missing. For the core ml models in ultralytics github page class labels are there. If its solved i can test my custom yolo models. Thank you.

    1. Glenn JocherUltralytics(editado)

      @CharanPrasadK it seems the class labels are not being included in your CoreML export. Ensure that your model is correctly labeled during training and export by checking the names attribute in the model. If the issue persists, please verify that you're using the latest ultralytics package. For further details, refer to the CoreML export documentation. Let us know if you need additional assistance!

  5. ChristalZhuGitHub

    Still the same problem, this is the result of running in the terminal: PyTorch: starting from '/Users/doublepeng/Desktop/best.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) ((1, 37, 8400), (1, 32, 160, 160)) (6.5 MB)

    CoreML: starting export with coremltools 7.2... CoreML: WARNING ⚠️ 'nms=True' is only available for Detect models like 'yolov8n.pt'. Tuple detected at graph output. This will be flattened in the converted model. Converting PyTorch Frontend ==> MIL Ops: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▌| 679/681 [00:00<00:00, 8273.25 ops/s] Running MIL frontend_pytorch pipeline: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [00:00<00:00, 157.94 passes/s] Running MIL default pipeline: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 78/78 [00:00<00:00, 82.56 passes/s] Running MIL backend_mlprogram pipeline: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 160.71 passes/s] CoreML: export success ✅ 7.7s, saved as '/Users/doublepeng/Desktop/best.mlpackage' (6.4 MB)

    Export complete (8.1s) Results saved to /Users/doublepeng/Desktop Predict: yolo predict task=segment model=/Users/doublepeng/Desktop/best.mlpackage imgsz=640 Validate: yolo val task=segment model=/Users/doublepeng/Desktop/best.mlpackage imgsz=640 data=/home/yujialin/Documents/xiaotong/corn/data/corn.yaml Visualize: https://netron.app In the run mlpackage file, the class label is still missing in General, and there is no preview. Since I am only doing corn segmentation, if possible, can I send you my .pt file?

    1. Glenn JocherUltralytics

      @ChristalZhu hello,

      Thank you for providing the detailed output from your terminal. It looks like the CoreML export process completed successfully, but you're experiencing issues with missing class labels and preview in the .mlpackage file.

      To assist you better, could you please confirm the following:

      1. Are you using the latest versions of torch and ultralytics? If not, please upgrade and try the export process again.
      2. Could you provide a minimum reproducible example of your code? This will help us understand the context and reproduce the issue on our end. You can refer to our minimum reproducible example guide for more details.

      Regarding your .pt file, we cannot accept direct file submissions. However, you can share the relevant code snippets and configurations you used for training and exporting the model.

      Here's a quick example of how to export a YOLOv8 model to CoreML and run inference:

      from ultralytics import YOLO
      
      # Load the YOLOv8 model
      model = YOLO("yolov8n.pt")
      
      # Export the model to CoreML format
      model.export(format="coreml")  # creates 'yolov8n.mlpackage'
      
      # Load the exported CoreML model
      coreml_model = YOLO("yolov8n.mlpackage")
      
      # Run inference
      results = coreml_model("https://ultralytics.com/images/bus.jpg")

      For more detailed instructions, you can visit our CoreML integration guide.

      Looking forward to your response so we can help resolve this issue.

  6. ChristalZhuGitHub

    我按照https://harshavardhanyellanki.github.io/YOLOV8_GUI/tasks/segmentation/的方法,将我自己训练的分割模型进行导出成mlpackage,但是出现了问题就是打开这个mlpackage之后,缺少class label文件和缺少了preview,请问这个有什么办法解决,如果可以的话,麻烦发送到我的email账号:wenpeng.zhu@foxmail.com万分感谢。 I followed the method at https://harshavardhanyellanki.github.io/YOLOV8_GUI/tasks/segmentation/ to export the segmentation model I trained myself into mlpackage, but the problem is that after opening this mlpackage, the class label file and the preview are missing. Is there any way to solve this problem? If possible, please send it to my email account: wenpeng.zhu@foxmail.com. Thank you very much.

    1. Paula DerrengerUltralytics

      Hello @ChristalZhu,

      Thank you for reaching out and providing details about the issue you're facing with exporting your YOLOv8 segmentation model to CoreML. Let's work together to resolve this.

      Firstly, please ensure that you are using the latest versions of torch and ultralytics. You can update them using the following commands:

      pip install --upgrade torch ultralytics

      If the issue persists, could you please provide a minimum reproducible code example? This will help us better understand the problem and investigate a solution. You can refer to our guide on creating a minimum reproducible example here: Minimum Reproducible Example.

      Regarding the missing class label file and preview in the .mlpackage, this can sometimes occur if the export process does not include all necessary metadata. Here is a Python example to ensure the export includes all required components:

      from ultralytics import YOLO
      
      # Load your trained YOLOv8 model
      model = YOLO("path/to/your/custom_model.pt")
      
      # Export the model to CoreML format
      model.export(format="coreml", nms=True)  # Ensure NMS is included for proper detection

      After exporting, you can manually check the .mlpackage to ensure it contains the necessary class labels and preview files. If they are still missing, please let us know, and we can further investigate.

      For more detailed instructions on exporting to CoreML, you can visit our documentation here: CoreML Export Guide.

      Feel free to share any additional details or errors you encounter. We're here to help!

    2. ChristalZhuGitHub

      Still the same problem, this is the result of running in the terminal: PyTorch: starting from '/Users/doublepeng/Desktop/best.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) ((1, 37, 8400), (1, 32, 160, 160)) (6.5 MB)

      CoreML: starting export with coremltools 7.2... CoreML: WARNING ⚠️ 'nms=True' is only available for Detect models like 'yolov8n.pt'. Tuple detected at graph output. This will be flattened in the converted model. Converting PyTorch Frontend ==> MIL Ops: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▌| 679/681 [00:00<00:00, 8273.25 ops/s] Running MIL frontend_pytorch pipeline: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [00:00<00:00, 157.94 passes/s] Running MIL default pipeline: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 78/78 [00:00<00:00, 82.56 passes/s] Running MIL backend_mlprogram pipeline: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 160.71 passes/s] CoreML: export success ✅ 7.7s, saved as '/Users/doublepeng/Desktop/best.mlpackage' (6.4 MB)

      Export complete (8.1s) Results saved to /Users/doublepeng/Desktop Predict: yolo predict task=segment model=/Users/doublepeng/Desktop/best.mlpackage imgsz=640
      Validate: yolo val task=segment model=/Users/doublepeng/Desktop/best.mlpackage imgsz=640 data=/home/yujialin/Documents/xiaotong/corn/data/corn.yaml
      Visualize: https://netron.app In the run mlpackage file, the class label is still missing in General, and there is no preview. Since I am only doing corn segmentation, if possible, can I send you my .pt file?

    3. Paula DerrengerUltralytics

      Hello @ChristalZhu,

      Thank you for providing the detailed output from your terminal. It looks like the CoreML export process completed successfully, but you're encountering issues with missing class labels and preview in the .mlpackage.

      To address this, please ensure you are using the latest versions of torch and ultralytics. You can update them using the following commands:

      pip install --upgrade torch ultralytics

      If the issue persists, could you please provide a minimum reproducible code example? This will help us better understand the problem and investigate a solution. You can refer to our guide on creating a minimum reproducible example here: Minimum Reproducible Example.

      Regarding the missing class label file and preview in the .mlpackage, this can sometimes occur if the export process does not include all necessary metadata. Here is a Python example to ensure the export includes all required components:

      from ultralytics import YOLO
      
      # Load your trained YOLOv8 model
      model = YOLO("path/to/your/custom_model.pt")
      
      # Export the model to CoreML format
      model.export(format="coreml", nms=True)  # Ensure NMS is included for proper detection

      After exporting, you can manually check the .mlpackage to ensure it contains the necessary class labels and preview files. If they are still missing, please let us know, and we can further investigate.

      For more detailed instructions on exporting to CoreML, you can visit our documentation here: CoreML Export Guide.

      Feel free to share any additional details or errors you encounter. We're here to help! 😊