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.
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#
| Propriedade | Detalhes |
|---|---|
Argumento format | coreml (aliases: mlpackage, mlprogram, apple, ios). mlmodel exporta o formato de rede neuronal anterior |
| Saída | yolo26n.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 em | iPhone, iPad, Mac, Apple Watch, Apple TV e Apple Vision Pro, na CPU, GPU e Apple Neural Engine |
| Ambiente de execução | Core 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ão | FP32, 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ção | macOS ou Linux x86-64, com Python 3.13 ou anterior. Não Windows. A exportação não precisa de GPU |
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:
| Pacote | Versão necessária |
|---|---|
| Python | 3.13 ou anterior, a versão mais recente para a qual coremltools 9.0 tem pacotes pré-compilados |
coremltools | 9.0 ou posterior |
numpy | 2.3.5 ou anterior. A exportação instala a versão 2.3.5 por cima de uma versão mais recente |
torch | 1.11 ou posterior |
scikit-learn | Apenas 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.
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:
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")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#
| Argumento | Tipo | Padrão | Descrição |
|---|---|---|---|
format | str | 'coreml' | Formato de destino do modelo exportado, que define a compatibilidade com vários ambientes de implantação. |
imgsz | int ou tuple | 640 | Tamanho 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. |
quantize | int ou str | None | Precisã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. |
nms | bool, opcional | None | Seleciona 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. |
conf | float | None | Limiar de confiança armazenado numa exportação nms=True. Usa 0.25 se não for definido. |
iou | float | 0.5 | Limiar IoU armazenado numa exportação nms=True. |
agnostic_nms | bool | False | Seleçã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_det | int | 300 | Nú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. |
dynamic | bool | False | Torna 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. |
batch | int | 1 | Maior tamanho de lote de uma exportação dynamic=True. Uma exportação predefinida tem tamanho de lote 1; outros valores geram um erro. |
device | str | None | Dispositivo 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.
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:
quantize | Pesos | Cálculo | SO mínimo | Tamanho do YOLO26n |
|---|---|---|---|---|
omitido ou 32 | FP32 | FP32 | iOS 15, macOS 12 | 9.9 MB |
16 | FP16 | FP16 | iOS 15, macOS 12 | 5.1 MB |
8 ou 'w8a16' | 8 bits | FP16 | iOS 16, macOS 13 | 2.7 MB |
- FP32: a predefinição quando
nms=Truenão está definido. Num Apple M4, as exportações FP32 das sete tarefas devolveram as mesmas saídas com as unidades de cálculoCPU_AND_NE, usadas pela Ultralytics, e comCPU_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=16armazena 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 (float32ouint32para segmentação semântica), pelo que o código de inferência escrito para o modelo FP32 é executado sem alterações. - INT8:
quantize=8equantize="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, quequantize=8seleciona para outros formatos; por isso, não aceita o argumentodata. Comscikit-learnjá 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.json | A lista de ficheiros no pacote |
Data/com.apple.CoreML/model.mlmodel | O 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.bin | Os 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:
| Tarefa | imgsz padrão | Saída com nms=None | Saída com nms=False | Saída com nms=True |
|---|---|---|---|---|
| Detecção | 640 | (1, 84, 8400) | (1, 300, 6) | confidence (boxes, 80) e coordinates (boxes, 4) |
| Segmentação | 640 | (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ântica | 1024 | (1, 1024, 1024), índice da classe de cada píxel | Igual a nms=None | Igual a nms=None |
| Profundidade | 768 | (1, 1, 768, 768), mapa de profundidade | Igual a nms=None | Igual a nms=None |
| Classificação | 224 | classLabel e classLabel_probs | Igual a nms=None | Igual a nms=None |
| Pose | 640 | (1, 56, 8400) | (1, 300, 57): 6 valores da caixa, seguidos de 17 pontos-chave x 3 | (1, 300, 57) |
| OBB | 1024 | (1, 20, 21504) | (1, 300, 7): 4 valores da caixa, pontuação, classe, ângulo | Igual 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 dex1, y1, x2, y2, score, classem píxeis da entrada, sem etapa NMS. As linhas OBB sãocenter 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. Devolveconfidence, uma linha de pontuações de classes para cada caixa mantida, ecoordinates, 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ção0.25),iou(predefinição0.5) eagnostic_nmssão armazenados no pipeline durante a exportação; as entradasconfidenceThresholdeiouThreshold, que podem ser omitidas, substituem os dois limiares numa previsão.max_detnão tem efeito: uma exportação commax_det=2ainda 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 preencheconfidencecom 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 devolvemax_detlinhas dex1, 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_nmsemax_detsã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, eclassLabel_probs, um dicionário de nomes de classes e probabilidades.coremltoolstambé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 comALL. Se o modelo não carregar com essas unidades, carrega-o comCPU_ONLY. Não existe um argumento para escolher outras unidades de cálculo; carrega o pacote comcoremltoolspara o fazer. Num Apple M4 com macOS 27.2,ALLeCPU_AND_GPUtambém executaram os modelos FP32, FP16 e INT8 das sete tarefas YOLO26n; outras versões do macOS não foram testadas. device: o argumentodevicenão seleciona o hardware Core ML. Comdevice="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 comdevice="mps", contra cerca de 6 ms sem ele; por isso, deixadevicesem definir.- Precisão e Neural Engine: num Apple M4, a etapa de inferência de
YOLO()demorou 18 a 20 ms por imagem empredictpara 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 comcoremltools, os mesmos modelos FP16 e INT8 demoraram cerca de 2 ms comCPU_AND_NE, contra 9 a 10 ms comCPU_ONLY. - Forma de entrada fixa: uma exportação predefinida é sempre executada com o
imgszda exportação, que a Ultralytics lê nos metadados do modelo. Umimgszpassado apredictouvalé 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, evaldefinebatch=1. - Exportação dinâmica (
dynamic=True): o modelo declara tamanhos de lote de 1 atébatchda exportação e tamanhos de imagem de 32 píxeis até ao dobro deimgszda exportação; a Ultralytics passa tamanhos de imagem em múltiplos do stride do modelo. A Ultralytics divide os lotes maiores em blocos debatchda exportação. Com a cabeça sem NMS, o tamanho mínimo é maior: 128 píxeis para um modelo YOLO26n exportado emimgsz=640comnms=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=640Adiciona 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#
- Integrar um modelo Core ML na tua aplicação: guia da Apple para adicionar um modelo a um projeto Xcode e invocá-lo.
- Reconhecer objetos em captura ao vivo: exemplo da Apple para executar um detetor Core ML em fotogramas da câmara com Vision e
VNCoreMLRequest. - MLComputeUnits: a definição
computeUnitsdeMLModelConfigurationque seleciona a CPU, a GPU e a Neural Engine. - Otimizar a utilização do Core ML: sessão da Apple sobre relatórios de desempenho do Xcode, que mostram a unidade de cálculo e a latência de cada camada num dispositivo.
- Guia Core ML Tools: referência de conversão e otimização do pacote
coremltoolsusado nesta exportação. - Ultralytics Platform: abre uma exportação Core ML na aplicação Ultralytics YOLO num iPhone, digitalizando um código QR.
- Core AI, LiteRT e Qualcomm QNN: o formato da Apple para iOS 27 e os formatos para dispositivos Android e NPUs Snapdragon.
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 registaRestart runtime or rerun command for updates to take effecte essa exportação falha comTypeError: 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:
coremltools9.0 publica pacotes pré-compilados apenas para macOS e Linux x86-64. - Versão de Python:
coremltools9.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 compilacoremltoolsa partir do código-fonte. A primeira exportação falha, tal como após uma instalação simples, e a seguinte é executada comRuntimeError: 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 comModel 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 comNo module named 'coremltools'num ambiente sem o pacote. - Checkpoints treinados com
quantize=8: um checkpoint ajustado com treino com reconhecimento da quantização falha comformat='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 comquantize=8, ou exporta o checkpoint ajustado para ONNX ou TensorRT. quantize="w8a32": falha comquantize='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 que8, com cálculo FP16.- NMS integrado noutras tarefas:
nms=Truefunciona com modelos de deteção, segmentação e pose. Para modelos OBB e de classificação, a exportação registaCoreML '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'.(oudepth 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=Truesemquantizeé FP16.quantize=32produz um pipeline FP32 para um modelo de deteção; para modelos de segmentação e pose, a exportação registaCoreML 'nms=True' requires FP16 for segment models. Forcing 'quantize=16'.(oupose models). - NMS integrado e validação: uma exportação
nms=Trueremove as caixas abaixo deconfantes devalas processar; por isso, obtém uma pontuação inferior à do mesmo modelo com NMS externo: no COCO val2017, uma exportação FP16 YOLO26n comnms=Trueobteve 33.8 mAPval 50-95 com oconf=0.25predefinido e 39.9 quando exportada comconf=0.001, ainda 1.0 abaixo dos 40.9 de uma exportação FP16 predefinida. Exporta comconf=0.001para validar esse modelo e escolhe separadamente o limiar de implementação. - Cabeça sem NMS noutros modelos:
nms=Falseprecisa de um modelo com uma cabeça sem NMS, como YOLO26 ou YOLOv10. Noutros modelos, por exemplo YOLO11, a exportação apresenta o avisoThis 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
batchsuperior a 1 semdynamic=Truefalha combatch sizes > 1 are not supported without 'dynamic=True' for CoreML export. Please retry at 'dynamic=True'.. - Formas dinâmicas:
dynamic=Truesembatchregista'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'.e exporta um modelo com tamanho máximo de lote 1. Comnms=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, comoSize (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_NEdo que comCPU_ONLY, usando apenascoremltoolsnuma imagem de teste: 59 a 64 ms, contra 22 ms para a exportação FP16 emimgsz=1024, e cerca de 15 ms, contra 9 ms, para a exportação INT8 emimgsz=640. Os modelos FP16 das outras seis tarefas e os respetivos modelos INT8 emimgsz=640(224 para classificação) foram executados mais rapidamente comCPU_AND_NE; no iPhone 17 Pro, o modelo semântico INT8 também foi mais rápido com a Neural Engine.YOLO()usa sempreCPU_AND_NEpara estes modelos; por isso, mede um modelo semântico com ambas as definições no teu próprio código. .cpuOnlyno iOS 27.0.1: num iPhone 17 Pro, a inferência.cpuOnlydos modelos de profundidade, pose e OBB YOLO26l e YOLO26x bloqueou dentro dos kernels da CPU do Core ML (EXC_BAD_ACCESSemlibBNNS). 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 dequantize,imgsz,nmsoudynamic; por isso, a exportação posterior substitui a anterior. Muda o nome do pacote para manter ambos e conserva o sufixo.mlpackage, por exemployolo26n_fp16.mlpackage, porque a Ultralytics identifica o formato por esse sufixo. Um pacote sem o sufixo falha comis not a supported model format. - Aviso sobre a versão do PyTorch: com uma versão recente do PyTorch,
coremltoolsregistaTorch version 2.15.0 has not been tested with coremltools. You may run into unexpected errors.ao carregar; com uma versão recente descikit-learn, registascikit-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
.mlmodelantigos:format="mlmodel"exporta o formato anterior de rede neuronal Core ML como um único ficheiroyolo26n.mlmodel, para aplicações que não conseguem carregar um ML Program. Nesse formato,quantize=8e'w8a16'aplicam quantização linear de pesos de 8 bits. Usa o.mlpackagepredefinido 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:
| Modelo | Tarefa | tamanho (pixels) | CPU Core ML .cpuOnly(ms) | CPU + Neural Engine Core ML .cpuAndNeuralEngine(ms) |
|---|---|---|---|---|
| YOLO26n | Detecção | 640 | 9.7 0.0 / 9.7 / 0.0 | 4.7 0.0 / 4.7 / 0.0 |
| YOLO26n-seg | Segmentação | 640 | 12.8 0.0 / 12.2 / 0.6 | 5.8 0.0 / 5.0 / 0.7 |
| YOLO26n-sem | Semântica | 640 | 9.3 0.0 / 8.9 / 0.5 | 5.3 0.0 / 4.8 / 0.5 |
| YOLO26n-depth | Profundidade | 640 | 25.8 0.0 / 24.8 / 1.0 | 8.0 0.0 / 6.9 / 1.1 |
| YOLO26n-cls | Classificação | 224 | 2.1 0.0 / 2.0 / 0.0 | 1.8 0.0 / 1.8 / 0.0 |
| YOLO26n-pose | Pose | 640 | 11.9 0.0 / 11.9 / 0.0 | 5.4 0.0 / 5.4 / 0.0 |
| YOLO26n-obb | OBB | 640 | 10.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:
| Modelo | CPU.cpuOnly(ms) | CPU + Neural Engine.cpuAndNeuralEngine(ms) | Carregamento do modelo.cpuAndNeuralEngine(s) |
|---|---|---|---|
| YOLO26n | 9.2 | 4.5 | 0.9 |
| YOLO26s | 19.5 | 10.5 | 1.3 |
| YOLO26m | 46.7 | 11.8 | 1.8 |
| YOLO26l | 60.1 | 12.0 | 2.4 |
| YOLO26x | 125.9 | 20.5 | 3.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ão | nms=None, CPU | nms=None, CPU + Neural Engine | nms=False, CPU | nms=False, CPU + Neural Engine |
|---|---|---|---|---|
| FP32 | 15.5 | 14.7 | 14.5 | 14.4 |
| FP16 | 9.2 | 4.9 | 9.2 | 5.0 |
| INT8 | 9.2 | 4.2 | 9.1 | 5.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..cpuOnlye.cpuAndNeuralEnginesã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 INT8nms=None. As tabelas de tarefas e tamanhos usam os recursos oficiaisv8.3.0, e a tabela de precisão usa exportações feitas comultralytics8.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
.cpuAndNeuralEnginedo 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.
| Modelo | imgsz | PyTorch | Core ML FP32 | Core ML FP16 | Core ML INT8 |
|---|---|---|---|---|---|
| YOLO26n | 640 | 25.6 | 21.0 | 6.0 | 6.0 |
| YOLO26s | 640 | 60.0 | 50.0 | 7.9 | 7.6 |
| YOLO26m | 640 | 137.2 | 127.6 | 14.3 | 11.3 |
| YOLO26l | 640 | 191.2 | 187.7 | 17.2 | 13.5 |
| YOLO26x | 640 | 341.1 | 334.2 | 28.6 | 24.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ão | CPU_ONLY | CPU_AND_NE | ALL | CPU_AND_GPU |
|---|---|---|---|---|
| FP32 | 13.7 | 13.6 | 8.3 | 8.0 |
| FP16 | 9.6 | 1.8 | 2.0 | 7.7 |
| INT8 | 9.4 | 1.8 | 1.8 | 8.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_NEe comCPU_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.
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=Trueconverte 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 objetosVNRecognizedObjectObservation, e a pontuação de uma caixa é oconfidenceda observação. Não carregues um modelo de deteçãonms=Truecom 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 predefinidanms=Nonedevolve 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.
Afool4U
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.
Sebastianxhj
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.
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.
smadsenjc
I have a trained model that is doing very well in Python, but once I convert it to CoreML
.mlpackageformat 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 fromVNCoreMLRequest: a singleVNCoreMLFeatureValueObservationinstead of an array ofVNRecognizedObjectObservation.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;Truefails).This was working back in November, but I got side-tracked with other work. I haven't touched the model.
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=Truerequires 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.
CharanPrasadK
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.
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
namesattribute in the model. If the issue persists, please verify that you're using the latestultralyticspackage. For further details, refer to the CoreML export documentation. Let us know if you need additional assistance!
ChristalZhu
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?
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
.mlpackagefile.To assist you better, could you please confirm the following:
- Are you using the latest versions of
torchandultralytics? If not, please upgrade and try the export process again. - 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
.ptfile, 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.
- Are you using the latest versions of
ChristalZhu
我按照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.
Paula DerrengerUltralyticsHello @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
torchandultralytics. You can update them using the following commands:pip install --upgrade torch ultralyticsIf 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 detectionAfter exporting, you can manually check the
.mlpackageto 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!
ChristalZhu
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?
Paula DerrengerUltralyticsHello @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
torchandultralytics. You can update them using the following commands:pip install --upgrade torch ultralyticsIf 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 detectionAfter exporting, you can manually check the
.mlpackageto 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! 😊
