Começar

Exportação para Intel OpenVINO

OpenVINO é o kit de ferramentas de código aberto da Intel para otimizar e executar inferência de IA. Exportar um modelo Ultralytics YOLO26 com format="openvino" cria um diretório yolo26n_openvino_model/ que contém um modelo OpenVINO IR (arquivos .xml e .bin) para CPUs Intel, GPUs Intel integradas e dedicadas e NPUs Intel, com precisão FP32, FP16 ou INT8.

Visão geral#

PropriedadeDetalhes
Argumento formatopenvino
Saídayolo26n_openvino_model/, um diretório com yolo26n.xml, yolo26n.bin e metadata.yaml; yolo26n_int8_openvino_model/ para uma exportação quantize=8
Funciona emCPUs Intel, GPUs Intel integradas e dedicadas e NPUs Intel. O dispositivo CPU também funciona em outros processadores x86-64 e ARM64, como AMD e Apple silicon
Ambiente de execuçãoOpenVINO Runtime 2024.0.0 ou mais recente (o pacote Python openvino)
PrecisãoFP32, FP16, INT8. O YOLO26n tem 10,1 MB em FP32, 5,3 MB em FP16 e 3,3 MB em INT8
Máquina de exportaçãoLinux, macOS ou Windows. A exportação é executada na CPU e não precisa de GPU
Exportar na nuvem

A Ultralytics Platform pode exportar por ti um modelo treinado para OpenVINO, para que não precises de um ambiente de exportação local.

Início rápido#

Instala o pacote Ultralytics com as dependências de exportação do OpenVINO:

pip install "ultralytics[export-openvino]"

Isto instala openvino e, no Python 3.9 ou mais recente, nncf para quantização INT8. Com um pip install ultralytics simples, a primeira exportação instala os pacotes em falta. A exportação tem estes requisitos de versão:

PacoteVersão necessária
torch2.1 ou mais recente
openvino2024.0.0 ou mais recente; 2025.2.0 ou mais recente no macOS 15.4 e posteriores
nncf2.14.0 ou mais recente, apenas para quantize=8; inferior a 3.0.0 com PyTorch anterior à versão 2.3

Para outros métodos de instalação, consulta o guia de instalação. Depois, exporta o teu modelo e carrega o diretório exportado para executar inferência ou validar a precisão. O curso OpenVINO na CPU explica os mesmos passos.

Exportar
from ultralytics import YOLO

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

# Exporta o modelo para o formato OpenVINO
model.export(format="openvino")  # creates 'yolo26n_openvino_model/'

# Exportar um modelo OpenVINO quantizado em INT8 com dados de calibração
model.export(format="openvino", quantize=8, data="coco8.yaml")  # creates 'yolo26n_int8_openvino_model/'
Prever
from ultralytics import YOLO

# Carrega o modelo OpenVINO exportado
model = YOLO("yolo26n_openvino_model/")

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

# Executar inferência na GPU Intel; usa "npu" para a NPU Intel ou "cpu" para a CPU
results = model("https://ultralytics.com/images/bus.jpg", device="xpu")
Validar
from ultralytics import YOLO

# Carrega o modelo OpenVINO exportado
model = YOLO("yolo26n_openvino_model/")

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

Tarefas suportadas#

A exportação OpenVINO é compatível com 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 estão disponíveis apenas com YOLO26, a única família que inclui essas cabeças.

Argumentos de exportação#

ArgumentoTipoPadrãoDescrição
formatstr'openvino'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: um inteiro para imagens quadradas ou uma tupla (height, width). Se não for informado, a exportação usa o tamanho com que o checkpoint foi treinado. Os checkpoints oficiais do YOLO26 usam 640 para detecção, segmentação, pose e modelos semânticos pré-treinados no ADE20K, 1024 para OBB e modelos semânticos pré-treinados no Cityscapes, 768 para profundidade e 224 para classificação.
quantizeint ou strNonePrecisão da quantização: 16 (FP16: os pesos são armazenados com precisão de meia precisão; as entradas e saídas permanecem em FP32) ou 8 (quantização INT8 pós-treinamento com NNCF usando imagens de calibração de data, gravadas num diretório _int8_openvino_model/); 32/não definido corresponde a FP32. Um checkpoint treinado com quantize=8 não pode ser exportado para OpenVINO; consulta Limitações e resolução de problemas. Substitui as flags obsoletas half/int8.
datastrNoneFicheiro YAML do conjunto de dados usado para a calibração INT8; a classificação usa, em vez disso, um diretório de conjunto de dados ou um nome de conjunto de dados integrado. A calibração usa a divisão val, a menos que split esteja definido. Se for omitido com quantize=8, Ultralytics usa o pequeno conjunto de dados predefinido para a tarefa do modelo, como coco8.yaml para deteção.
fractionfloat, int ou list1.0Subconjunto de calibração como proporção, número de imagens ou proporções/contagens [train, val, test]. Listas de dois itens deixam test completo, enquanto 0 o ignora.
dynamicboolFalseTorna dinâmicos o lote, a altura e a largura da entrada, para que um modelo aceite diferentes tamanhos de lote e de imagem. Numa NPU Intel, um modelo dinâmico continua a ser executado com imgsz da exportação; consulta Implementação.
nmsbool, opcionalNoneSeleciona a saída bruta (None, padrão), NMS integrado (True) ou a cabeça sem NMS (False). Consulte o formato de saída.
batchint1Tamanho do lote do modelo exportado. Numa exportação estática, este tamanho de lote fica fixo na forma da entrada. É também o tamanho do lote usado na calibração INT8.
devicestrNoneA exportação é sempre executada na CPU. Com quantize=8, device=npu seleciona ativações INT8 simétricas para modelos YOLO de deteção, segmentação, pose e OBB, que podem ser até 2 vezes mais rápidos em NPUs Intel.

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

Quantização INT8#

quantize=8 aplica quantização pós-treinamento com NNCF: a exportação executa imagens de calibração no modelo e armazena pesos e ativações como inteiros de 8 bits sempre que possível.

  • Dados de calibração: a exportação calibra com cada lote completo da divisão val de data, ou da divisão definida com split. Usa fraction para limitar o número de imagens. A exportação apresenta um aviso com menos de 300 imagens.
  • Cabeça de deteção: nos modelos com uma cabeça de deteção YOLO (deteção, segmentação, pose e OBB) e no RT-DETR, as operações que descodificam as saídas da cabeça (reshape, concatenação, descodificação de caixas e DFL) e todas as operações sigmoid permanecem em ponto flutuante, enquanto as convoluções da cabeça são quantizadas. Os modelos de classificação, segmentação semântica e profundidade não têm operações excluídas.
  • Entradas e saídas: um modelo INT8 mantém a entrada float32 e as saídas do modelo FP32, pelo que o código de inferência escrito para o modelo FP32 funciona sem alterações.
  • NPU Intel: adiciona device=npu a uma exportação INT8 que planeias executar numa NPU Intel. Isto muda os modelos YOLO de deteção, segmentação, pose e OBB da quantização assimétrica para a quantização simétrica das ativações.
Exemplo
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Calibrar com 10% das imagens de validação COCO (500 imagens); substitua coco.yaml pelo seu próprio conjunto de dados
model.export(format="openvino", quantize=8, data="coco.yaml", fraction=0.1)

# Carregar o modelo INT8 exportado e executar inferência
model = YOLO("yolo26n_int8_openvino_model/")
results = model("https://ultralytics.com/images/bus.jpg")

Nos benchmarks, os modelos INT8 foram de 1,02 a 1,33 vezes mais rápidos que os modelos FP32 numa CPU de servidor e perderam 0,5 a 0,9 mAP no COCO val2017. Nas CPUs Intel Core Ultra, o INT8 foi de 1,2 a 3,8 vezes mais rápido que o FP32. Valida um modelo INT8 com os teus próprios dados antes de o implementar.

Formato de saída#

A exportação grava um diretório com três ficheiros:

FicheiroConteúdo
yolo26n.xmlO grafo da rede no formato OpenVINO IR
yolo26n.binOs pesos
metadata.yamlNomes das classes, tarefa, tamanho da imagem, tamanho do lote, stride e argumentos de exportação, que Ultralytics lê ao carregar o modelo

O modelo recebe uma entrada com a forma (batch, 3, height, width), em RGB e escalada para 0-1. A entrada e as saídas são float32 em modelos FP32, FP16 e INT8, exceto a saída de segmentação semântica, que é um mapa de classes uint8 (int32 para modelos com mais de 256 classes). Os tensores não têm os nomes images e output0 da exportação ONNX, por isso, no teu próprio código, acede à entrada e às saídas pelo índice.

As formas das saídas são iguais às da exportação ONNX e dependem da tarefa e do argumento nms: um modelo de deteção YOLO26n exportado em imgsz=640 devolve (1, 84, 8400) com o nms=None predefinido e (1, 300, 6) com nms=False ou nms=True. Consulta o formato de saída ONNX para ver as formas e os conteúdos de cada tarefa. Com nms=True, o limiar de confiança conf (predefinição 0.25), o limiar IoU iou, agnostic_nms e max_det ficam fixos no grafo durante a exportação. Um valor conf inferior durante a predição ou validação não recupera as deteções que o grafo já removeu, por isso, volta a exportar para alterar estes valores.

Implantar#

YOLO("yolo26n_openvino_model/") executa o modelo com OpenVINO Runtime e mapeia o argumento device para um dispositivo OpenVINO:

deviceDispositivo OpenVINO
sem definirAUTO, que permite ao OpenVINO escolher entre a CPU e as GPUs Intel (a lista de prioridades predefinida exclui a NPU), ou CPU quando a CPU é o único dispositivo detetado pelo OpenVINO
cpuCPU
xpu ou xpu:0GPU ou GPU.0, a GPU Intel integrada ou dedicada. xpu:1 seleciona GPU.1 numa máquina com duas GPUs Intel
npuNPU, a unidade de processamento neural dos processadores Intel Core Ultra

Outros valores, como 0 ou mps, são tratados como se device não estivesse definido. Os nomes mais antigos intel:cpu, intel:gpu e intel:npu continuam a funcionar e geram um aviso de obsolescência. A tabela de dispositivos de inferência compara estes nomes entre formatos. A linha de registo Using OpenVINO LATENCY mode for batch=1 inference on CPU... indica o dispositivo reportado pelo OpenVINO ao carregar o modelo. Com AUTO, pode ser a CPU enquanto uma GPU Intel ainda compila o modelo, por isso define device para teres a certeza. Para um modelo .pt, device="xpu" seleciona, em vez disso, o backend Intel GPU de PyTorch, que também é o dispositivo para treino em GPUs Intel, e device="npu" seleciona uma NPU Huawei Ascend, não a NPU Intel.

O comportamento durante a inferência depende da forma como o modelo foi exportado:

  • Exportação estática (predefinição): o modelo é sempre executado com os valores de exportação imgsz e batch, que Ultralytics lê de metadata.yaml. Um imgsz passado a predict é ignorado. Os lotes maiores são divididos em blocos do tamanho do lote de exportação e os menores são preenchidos, pelo que funciona qualquer número de imagens.
  • Exportação dinâmica (dynamic=True): predict aceita diferentes tamanhos de lote e qualquer imgsz que seja múltiplo do stride do modelo. As NPUs Intel e os modelos INT8 em CPUs Intel AMX são exceções; consulta Limitações e resolução de problemas.
  • Modo de latência: Ultralytics compila o modelo com a indicação de desempenho LATENCY do OpenVINO e executa a inferência de forma síncrona. Para processar muitos pedidos em paralelo com a indicação THROUGHPUT, usa a API OpenVINO Runtime, conforme explicado no guia de latência e débito.
  • NPU Intel: Ultralytics compila o modelo para tamanho de lote 1 numa NPU e divide os lotes maiores em imagens individuais. Numa NPU, uma exportação dinâmica fica fixa no valor de exportação imgsz.

Executar com a API OpenVINO Runtime#

Para executar o modelo fora do pacote Ultralytics, carrega o ficheiro .xml com o pacote openvino. O modelo espera uma imagem pré-processada e devolve as saídas em bruto descritas em Formato de saída, por isso, o letterboxing e, numa exportação predefinida, o NMS ficam a cargo do teu código:

# Exporta primeiro: yolo export model=yolo26n.pt format=openvino nms=False
import numpy as np
import openvino as ov
import yaml

core = ov.Core()
model = core.read_model("yolo26n_openvino_model/yolo26n.xml")
compiled = core.compile_model(model, "AUTO")  # ou "CPU", "GPU", "NPU"

image = np.zeros((1, 3, 640, 640), dtype=np.float32)  # a tua imagem pré-processada: RGB, NCHW, 0-1
detections = compiled(image)[0][0]  # primeira saída, primeira imagem: forma (300, 6)
detections = detections[detections[:, 4] > 0.25]  # manter as linhas acima do limiar de confiança

with open("yolo26n_openvino_model/metadata.yaml") as f:
    names = yaml.safe_load(f)["names"]  # {0: 'person', 1: 'bicycle', ...}

Guias de implantação#

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

  • Versão do PyTorch: a exportação falha com OpenVINO export requires torch>=2.1 em versões mais antigas do PyTorch.
  • macOS 15.4 e posteriores: OpenVINO 2025.1.0 e versões anteriores falham nestas versões do macOS, por isso, a exportação requer openvino>=2025.2.0 e atualiza um pacote mais antigo.
  • Checkpoints treinados com quantize=8: um checkpoint ajustado com treino com reconhecimento da quantização falha com format='openvino' 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.
  • Exportação INT8 sem data: a exportação regista INT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'. e calibra com o pequeno conjunto de dados predefinido para a tarefa. Passa data com imagens representativas dos dados de implementação.
  • Tamanho da calibração INT8: a exportação regista >300 images recommended for INT8 calibration, found 4 images. quando a divisão de calibração tem menos de 300 imagens. coco8.yaml tem apenas 4 imagens de validação, o suficiente para testar a exportação, mas não para calibrar um modelo para implementação.
  • Diretório de saída: cada exportação de um checkpoint que não seja INT8 grava o mesmo diretório yolo26n_openvino_model/, independentemente de quantize, imgsz, dynamic, nms ou batch, pelo que a exportação seguinte substitui a anterior. Todas as exportações INT8, com ou sem device=npu, partilham yolo26n_int8_openvino_model/.
  • Dispositivo indisponível: quando o dispositivo pedido não está disponível, Ultralytics regista OpenVINO device 'GPU' not available. Using 'AUTO' instead. (ou Using 'CPU' instead. numa máquina em que o OpenVINO só deteta a CPU) e continua nesse dispositivo. Confirma que o teu processador é compatível com OpenVINO e instala o controlador Intel para GPU ou NPU.
  • NPU Intel: Ultralytics executa uma NPU com tamanho de lote 1 e formas de entrada fixas; consulta Implementação. Passa device=npu para a usar: se device não estiver definido, a NPU não é selecionada.
  • Formas dinâmicas com NMS: uma exportação com dynamic=True e nms=True regista 'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'. quando batch permanece definido como 1. Ultralytics executa lotes maiores em blocos do tamanho do lote batch da exportação.
  • Modelos INT8 dinâmicos em CPUs Intel AMX: no Linux com uma CPU compatível com AMX (Intel Sapphire Rapids e mais recentes), Ultralytics executa um modelo INT8 dinâmico no dispositivo CPU ou AUTO com o tamanho de lote imgsz da exportação, tal como faz com um modelo estático: um imgsz passado a predict ou val é ignorado, e val usa o batch da exportação. predict continua a aceitar outros tamanhos de lote e recompila o modelo para cada novo tamanho de lote, pelo que a primeira inferência com um novo tamanho de lote é mais lenta.
  • Windows: no Windows, Ultralytics define a indicação de precisão de inferência da CPU como FP32, o que impede o OpenVINO de usar kernels de ponto flutuante de menor precisão (os modelos INT8 continuam a ser executados em INT8), e limita oneDNN a conjuntos de instruções anteriores ao AMX. Define a variável de ambiente ONEDNN_MAX_CPU_ISA antes de carregar o modelo para usar outro limite.
  • Linux em ARM64: Ultralytics executa o dispositivo CPU no modo de execução de precisão do OpenVINO, com precisão de inferência FP32.
  • NMS incorporado: nms=True gera 'nms=True' is not valid for classification models. para classificação e é ignorado com um aviso nos modelos de segmentação semântica e estimativa de profundidade ('nms=True' is not valid for semantic models. Forcing 'nms=None'.) e nos modelos RT-DETR ('nms=True' is not available for end2end models or non-YOLO heads. Forcing 'nms=None'.).
  • Cabeça sem NMS: nms=False requer um modelo com cabeça sem NMS, como YOLO26 ou YOLOv10. Para outros modelos, por exemplo, YOLO11, a exportação exibe o aviso This model has no one-to-one head; using one-to-many outputs. e grava a saída bruta (1, 84, 8400).

Para outros erros, consulte o guia de problemas comuns.

Benchmarks do YOLO26 com OpenVINO#

As tabelas abaixo comparam PyTorch com modelos OpenVINO FP32, FP16 e INT8 de todos os modelos de deteção YOLO26. O primeiro conjunto foi medido numa CPU de servidor com a precisão COCO val2017; o segundo, em três processadores Intel Core Ultra com as respetivas CPU e GPU, e com a NPU de dois deles. A página dos modelos YOLO26 apresenta a precisão, a velocidade ONNX na CPU e a velocidade TensorRT na T4 de cada modelo.

FP32, FP16 e INT8 numa CPU de servidor#

Todos os valores desta secção foram medidos na CPU de um servidor com dois processadores AMD EPYC 9655 de 96 núcleos, não numa CPU Intel. PyTorch foi executado com 8 threads e OpenVINO com 96 threads, as predefinições escolhidas por Ultralytics e OpenVINO nesse servidor, pelo que as colunas de PyTorch e OpenVINO diferem tanto na quantidade de threads como no ambiente de execução. PyTorch também validou com inferência retangular, com cada imagem preenchida até formar um retângulo que segue a respetiva proporção (512x672 para uma imagem 480x640), enquanto os modelos OpenVINO estáticos foram sempre executados em 640x640.

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

ModeloimgszPyTorchOpenVINO FP32OpenVINO FP16OpenVINO INT8
YOLO26n64013.313.413.333.35
YOLO26s64024.285.185.184.51
YOLO26m64049.948.398.346.60
YOLO26l64063.7510.9211.058.94
YOLO26x640115.1117.1217.1612.83

YOLO26n nas mesmas 8 CPUs (PyTorch e OpenVINO ambos associados às CPUs 0-7 desse servidor com taskset):

MétricaPyTorchOpenVINO FP32OpenVINO FP16OpenVINO INT8
Latência (ms/imagem)9.287.137.146.71
mAPval 50-9540.840.940.940.3
  • OpenVINO FP32 foi de 3,9 a 6,7 vezes mais rápido que PyTorch com as quantidades de threads predefinidas indicadas acima, com a mesma precisão, dentro de 0,1 mAP. Com ambos associados às mesmas 8 CPUs, onde PyTorch foi mais rápido do que na configuração predefinida, OpenVINO FP32 executou YOLO26n 1,3 vezes mais rápido que PyTorch e INT8 foi 1,06 vezes mais rápido que FP32.
  • FP16 reduziu o tamanho do modelo para metade, com uma diferença de até 0,1 mAP em relação a FP32 e uma latência equivalente à de FP32 (diferença de até 3%).
  • INT8 foi de 1,02 a 1,33 vezes mais rápido que FP32, tornou o modelo 3,1 a 3,9 vezes menor e perdeu 0,5 a 0,9 mAP.

Medido com ultralytics 8.4.212, OpenVINO 2026.4.1, NNCF 3.4.0 e PyTorch 2.15.0 em batch=1, a 14 de novembro de 2026. A latência é a etapa de inferência reportada por val e não inclui pré-processamento nem pós-processamento. Os valores de PyTorch, FP32 e FP16 são a média de três execuções, que diferiram até 26% para PyTorch e 6% para OpenVINO. Os modelos INT8 foram calibrados com 591 imagens COCO train2017 (split=train fraction=0.005) e compilados três vezes; os valores INT8 são a média das três compilações. A tabela de 8 CPUs usa uma única compilação INT8 executada três vezes.

CPU, GPU e NPU Intel Core Ultra#

Estas tabelas foram medidas em três processadores Intel Core Ultra com openvino 2026.2.1 no modo de benchmark: model.benchmark(data="coco128.yaml", format="openvino", device=...), com device definido como cpu, xpu ou npu. A precisão corresponde a mAP50-95 no conjunto de dados COCO128, com 128 imagens, pelo que não é comparável com os valores COCO val2017 acima. PyTorch foi executado na CPU do mesmo processador. Os modelos YOLO26 só funcionam na NPU dos processadores Intel Core Ultra das séries 2xxV e 3xx, e dos processadores mais recentes.

Intel Core Ultra X7 358H#

O Intel Core Ultra X7 358H (Panther Lake) combina núcleos de CPU, uma GPU Intel Arc integrada e uma NPU Intel AI Boost.

Milissegundos por imagem; quanto menor, melhor. A coluna mais rápida de cada modelo está a negrito.

ModeloCPU PyTorchCPU FP32CPU FP16CPU INT8GPU FP32GPU FP16GPU INT8NPU FP32NPU FP16NPU INT8
YOLO26n29.2814.3514.239.994.094.034.247.687.718.60
YOLO26s59.3235.0333.5516.685.085.144.479.899.9410.69
YOLO26m143.2190.5388.8233.337.107.065.6113.0213.1314.84
YOLO26l181.16112.83111.3143.278.458.496.2514.5314.5515.64
YOLO26x379.75241.21236.8778.9213.0312.988.7423.4823.4121.56

Processadores Intel Core Ultra anteriores#

Intel Core Ultra 7 258V (Lunar Lake)

Milissegundos por imagem; quanto menor, melhor. A coluna mais rápida de cada modelo está a negrito.

ModeloCPU PyTorchCPU FP32CPU FP16CPU INT8GPU FP32GPU FP16GPU INT8NPU FP32NPU FP16NPU INT8
YOLO26n27.3316.8416.738.623.333.343.4623.7123.7023.96
YOLO26s60.2054.7154.4520.194.664.653.9926.6226.6225.89
YOLO26m152.87178.59179.2553.079.038.985.7032.9433.0130.95
YOLO26l201.57238.15233.7067.7311.3211.367.4536.0235.7732.64
YOLO26x431.04567.22561.39151.1119.0819.6313.6949.6449.6941.75
Intel Core Ultra 7 155H (Meteor Lake)

Milissegundos por imagem; quanto menor, melhor. A coluna mais rápida de cada modelo está a negrito.

ModeloCPU PyTorchCPU FP32CPU FP16CPU INT8GPU FP32GPU FP16GPU INT8
YOLO26n33.1913.4313.2011.409.139.075.79
YOLO26s70.9236.1636.0715.5416.3716.659.27
YOLO26m192.45102.52101.8835.7234.4735.7115.46
YOLO26l239.19129.24128.5045.3843.2443.4019.72
YOLO26x511.89293.40296.4885.2479.4979.4534.66

Nos três processadores:

  • CPU: INT8 foi de 1.2 a 3.8 vezes mais rápido que FP32 e de 2.9 a 6.0 vezes mais rápido que PyTorch. FP32 foi de 1.6 a 2.5 vezes mais rápido que PyTorch no X7 358H e no 155H, mas foi mais lento que PyTorch para YOLO26m, YOLO26l e YOLO26x no 258V.
  • GPU: a GPU integrada executou modelos FP32 de 3.6 a 29.1 vezes mais rápido que PyTorch na CPU. INT8 foi mais rápido que FP32 em todos os modelos, exceto YOLO26n no X7 358H e no 258V, com ganhos de até 2.3 vezes.
  • NPU (X7 358H e 258V): os modelos FP32 foram executados de 1.2 a 16.2 vezes mais rápido que PyTorch na CPU, e INT8 foi de 0.88 a 1.19 vezes tão rápido quanto FP32. Esses modelos INT8 foram exportados antes de device=npu selecionar ativações simétricas, portanto as tabelas não mostram a exportação INT8 ajustada para NPU.
  • A latência de FP16 ficou dentro de 5% da latência de FP32 em todos os dispositivos, e INT8 perdeu de 0.1 a 2.7 pontos de mAP50-95.

Sobre o OpenVINO#

OpenVINO, abreviação de Inferência Visual Aberta e Otimização de Redes Neurais, converte modelos de frameworks como PyTorch para o formato IR e os executa por meio de uma API em CPUs, GPUs e NPUs Intel. Para consultar a referência completa, veja a documentação do OpenVINO.

OpenVINO Intel AI inference toolkit



Assista: Como exportar Ultralytics YOLO26 para o formato Intel OpenVINO para acelerar a inferência 🚀

Perguntas frequentes#

  • Sim, na CPU. O dispositivo CPU do OpenVINO funciona em processadores x86-64 e ARM64: os benchmarks de CPU para servidores desta página foram medidos em processadores AMD EPYC, e a mesma exportação funciona no Apple silicon. Os dispositivos GPU e NPU precisam de hardware Intel; por isso, device=xpu e device=npu recorrem a uma alternativa e exibem um aviso em outras máquinas. Para outros destinos, veja o guia de opções de implantação de modelos.

  • Depende do dispositivo. FP16 (quantize=16) não precisa de dados de calibração, reduz o tamanho do modelo pela metade e manteve a precisão e a latência de FP32 nos benchmarks, então use-o quando o tamanho do modelo for importante. INT8 (quantize=8) apresentou a menor latência de CPU para a maioria dos modelos: na CPU de servidor, reduziu a latência do YOLO26s de 5.18 ms para 4.51 ms por imagem, com 47.6 mAPval 50-95, em comparação com 48.5 em FP32; nas CPUs Intel Core Ultra, foi de 1.2 a 3.8 vezes mais rápido que FP32. Nas GPUs Intel integradas, o ganho de INT8 foi menor, de até 2.3 vezes, e nas NPUs os modelos INT8 destes testes, exportados sem device=npu, foram quase tão rápidos quanto FP32. INT8 precisa de dados de calibração representativos, então valide o modelo INT8 com os seus próprios dados antes de escolhê-lo.

  • Exporte com dynamic=True e passe o lote e o imgsz necessários no momento da predição. O tamanho da imagem precisa ser múltiplo do stride do modelo, que é 32 para os checkpoints oficiais do YOLO26, exceto os de classificação; veja Implantação para conhecer as exceções.

    Exportação dinâmica
    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    model.export(format="openvino", dynamic=True)
    
    model = YOLO("yolo26n_openvino_model/")
    results = model(["https://ultralytics.com/images/bus.jpg"] * 4, imgsz=320)  # um lote de 4 imagens a 320 pixels
  • Use OpenVINO quando o hardware de implantação for Intel: device=xpu e device=npu selecionam a GPU e a NPU Intel, e os modelos OpenVINO INT8 foram de 1.2 a 3.8 vezes mais rápidos que FP32 nas CPUs Intel Core Ultra nos benchmarks. Use ONNX quando o mesmo arquivo também precisar funcionar em GPUs NVIDIA ou AMD, ou em runtimes além do OpenVINO; no Windows, o Windows ML pode selecionar hardware Intel para um modelo ONNX.

Comentários23

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

  1. EduardoNewGitHub

    I encountered some difficulties while trying to run the official video demo. Here is my code:

    from ultralytics import YOLO

    def main(): # Load a YOLOv8n PyTorch model model = YOLO("yolov8n.pt")

    # Export the model
    model.export(format="openvino")  # creates 'yolov8n_openvino_model/'
    
    # Load the exported OpenVINO model with explicit task definition
    ov_model = YOLO("yolov8n_openvino_model\\", task='detect')  # Explicitly define task as 'detect'
    
    # Run inference
    results_original = model("D:\\python_YOLO_test\\bus.jpg")
    
    # Run ov inference
    results_ov = ov_model("D:\\python_YOLO_test\\bus.jpg")

    if name == "main": main() Additional notes: My environment is openvino==2024.0.0, and I executed pip install --upgrade torch ultralytics.

    The issue I encountered is as follows:

    Results saved to D:\python_YOLO_test Ultralytics YOLOv8.2.57 🚀 Python-3.11.9 torch-2.1.1+cu118 CPU (11th Gen Intel Core(TM) i7-11800H 2.30GHz) YOLOv8n summary (fused): 168 layers, 3,151,904 parameters, 0 gradients, 8.7 GFLOPs

    PyTorch: starting from 'yolov8n.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) (1, 84, 8400) (6.2 MB)

    OpenVINO: starting export with openvino 2024.0.0-14509-34caeefd078-releases/2024/0... OpenVINO: export success ✅ 2.8s, saved as 'yolov8n_openvino_model' (12.3 MB)

    Export complete (5.2s) Results saved to D:\python_YOLO_test Predict: yolo predict task=detect model=yolov8n_openvino_model imgsz=640
    Validate: yolo val task=detect model=yolov8n_openvino_model imgsz=640 data=coco.yaml
    Visualize: https://netron.app

    image 1/1 D:\python_YOLO_test\bus.jpg: 640x480 4 persons, 1 bus, 1 stop sign, 324.0ms Speed: 24.0ms preprocess, 324.0ms inference, 21.0ms postprocess per image at shape (1, 3, 640, 480) Loading yolov8n_openvino_model for OpenVINO inference... Using OpenVINO LATENCY mode for batch=1 inference...

    Process finished with exit code -1073741819 (0xC0000005)

    Process finished with exit code -1073740791 (0xC0000409) The model was successfully exported but did not perform inference, instead, it terminated directly. How should I resolve this issue?

    1. Glenn JocherUltralytics(editado)

      @EduardoNew the exit code 0xC0000005 often indicates a memory access violation. Let's address this step-by-step:

      1. Path Format: Try using forward slashes in your OpenVINO model path: "yolov8n_openvino_model/" instead of backslashes.

      2. OpenVINO Version: Ultralytics requires openvino>=2024.0.0. Try upgrading to a recent release:

      pip install -U openvino
      1. Hardware Compatibility: Ensure you have the latest Intel drivers installed from Intel's official site.

      If issues persist, please create a Minimum Reproducible Example and open a GitHub Issue following our bug report guidelines. We'll be happy to investigate further!

  2. Ranjith3436GitHub

    You mentioned that the core CPU inference model takes 23.53 ms. I would like to know if the processing time decreases when we increase the number of CPU cores ? currently i am using 12 thread CPU.

    1. Glenn JocherUltralytics

      @Ranjith3436 increasing the number of CPU cores can potentially reduce processing time, as it allows for parallel processing, but the actual speedup will depend on the model's ability to leverage multi-threading effectively.

    2. Glenn JocherUltralytics

      To assess a model's ability to utilize multiple CPU cores, you can check its support for multi-threading or parallel processing in the documentation or by running benchmarks on your hardware configuration.

  3. kimchi2020GitHub

    hey i am working on object detection in videos and came across openvino that helps in increasing speed. how can i use openvino and yolov8 together to find objects in a video

    1. Glenn JocherUltralytics

      @kimchi2020 hi there! It's great to hear that you're exploring OpenVINO to enhance the speed of your object detection tasks in videos. OpenVINO can indeed provide significant performance improvements, especially on Intel hardware.

      To get started with using YOLOv8 and OpenVINO together, follow these steps:

      Exporting YOLOv8 to OpenVINO Format
      1. Export the Model: You can export your YOLOv8 model to the OpenVINO format using the following Python code:

        from ultralytics import YOLO
        
        # Load a YOLOv8n PyTorch model
        model = YOLO("yolov8n.pt")
        
        # Export the model to OpenVINO format
        model.export(format="openvino")  # creates 'yolov8n_openvino_model/'

        Alternatively, you can use the CLI:

        yolo export model=yolov8n.pt format=openvino  # creates 'yolov8n_openvino_model/'
      2. Run Inference with the Exported Model: After exporting, you can run inference using the exported OpenVINO model. Here’s how you can do it in Python:

        from ultralytics import YOLO
        
        # Load the exported OpenVINO model
        ov_model = YOLO("yolov8n_openvino_model/")
        
        # Run inference
        results = ov_model("https://ultralytics.com/images/bus.jpg")

        Or using the CLI:

        yolo predict model=yolov8n_openvino_model source='https://ultralytics.com/images/bus.jpg'
      Running Inference on Videos

      To process videos, you can modify the inference code to read frames from a video file and run the model on each frame. Here’s an example in Python:

      import cv2
      from ultralytics import YOLO
      
      # Load the exported OpenVINO model
      model = YOLO("yolov8n_openvino_model/")
      
      # Open the video file
      video_path = "path/to/your/video.mp4"
      cap = cv2.VideoCapture(video_path)
      
      # Loop through the video frames
      while cap.isOpened():
          ret, frame = cap.read()
          if not ret:
              break
      
          # Run inference on the frame
          results = model(frame)
      
          # Visualize the results on the frame
          annotated_frame = results[0].plot()
      
          # Display the annotated frame
          cv2.imshow("YOLOv8 OpenVINO Inference", annotated_frame)
      
          # Break the loop if 'q' is pressed
          if cv2.waitKey(1) & 0xFF == ord('q'):
              break
      
      # Release the video capture object and close the display window
      cap.release()
      cv2.destroyAllWindows()
      Additional Resources

      For more detailed information and advanced usage, you can refer to the OpenVINO documentation. This guide covers everything from exporting models to running inference and optimizing performance.

      Feel free to reach out if you have any more questions. Happy coding! 🚀

    2. kimchi2020GitHub

      Traceback (most recent call last): File "/home/kimchi/Desktop/yolov8/onnx.py", line 18, in results = model(frame) ^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/model.py", line 174, in call return self.predict(source, stream, **kwargs) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/model.py", line 442, in predict return self.predictor.predict_cli(source=source) if is_cli else self.predictor(source=source, stream=stream) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/predictor.py", line 168, in call return list(self.stream_inference(source, model, *args, **kwargs)) # merge list of Result into one ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torch/utils/_contextlib.py", line 35, in generator_context response = gen.send(None) ^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/predictor.py", line 234, in stream_inference self.model.warmup(imgsz=(1 if self.model.pt or self.model.triton else self.dataset.bs, 3, *self.imgsz)) File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/nn/autobackend.py", line 626, in warmup import torchvision # noqa (import here so torchvision import time not recorded in postprocess time) ^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/init.py", line 6, in from torchvision import _meta_registrations, datasets, io, models, ops, transforms, utils File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/models/init.py", line 2, in from .convnext import * File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/models/convnext.py", line 8, in from ..ops.misc import Conv2dNormActivation, Permute File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/ops/init.py", line 1, in from ._register_onnx_ops import _register_custom_op File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/ops/_register_onnx_ops.py", line 5, in from torch.onnx import symbolic_opset11 as opset11 File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torch/onnx/init.py", line 59, in from ._internal.onnxruntime import ( File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torch/onnx/_internal/onnxruntime.py", line 36, in import onnx File "/home/kimchi/Desktop/yolov8/onnx.py", line 18, in results = model(frame) ^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/model.py", line 174, in call return self.predict(source, stream, **kwargs) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/model.py", line 442, in predict return self.predictor.predict_cli(source=source) if is_cli else self.predictor(source=source, stream=stream) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/predictor.py", line 168, in call return list(self.stream_inference(source, model, *args, **kwargs)) # merge list of Result into one ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torch/utils/_contextlib.py", line 35, in generator_context response = gen.send(None) ^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/predictor.py", line 261, in stream_inference self.results = self.postprocess(preds, im, im0s) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/models/yolo/detect/predict.py", line 25, in postprocess preds = ops.non_max_suppression( ^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/utils/ops.py", line 291, in non_max_suppression i = torchvision.ops.nms(boxes, scores, iou_thres) # NMS ^^^^^^^^^^^^^^^ AttributeError: partially initialized module 'torchvision' has no attribute 'ops' (most likely due to a circular import). Did you mean: 'os'?

      I am getting this error, how to get rid of it and what does it mean

    3. Glenn JocherUltralytics

      Hi @kimchi2020,

      Thank you for reaching out! The error you're encountering seems to be related to a circular import issue with the torchvision library. This can happen if there's a naming conflict or an import loop in your code.

      Steps to Resolve the Issue:
      1. Check for Naming Conflicts: Ensure that your script name (onnx.py) is not conflicting with any library names. Rename your script to something unique, like run_inference.py.

      2. Verify Installation: Make sure you have the latest versions of torch, torchvision, and ultralytics installed. You can update them using:

        pip install --upgrade torch torchvision ultralytics
      3. Reproduce the Issue: If the issue persists, please provide a minimum reproducible example. This helps us diagnose the problem more effectively. You can refer to our guide on creating a reproducible example here: Minimum Reproducible Example.

      Example Code for Inference with OpenVINO:

      Here's a quick example of how to export your YOLOv8 model to OpenVINO and run inference on a video:

      import cv2
      from ultralytics import YOLO
      
      # Load a YOLOv8n PyTorch model
      model = YOLO("yolov8n.pt")
      
      # Export the model to OpenVINO format
      model.export(format="openvino")  # creates 'yolov8n_openvino_model/'
      
      # Load the exported OpenVINO model
      ov_model = YOLO("yolov8n_openvino_model/")
      
      # Open the video file
      video_path = "path/to/your/video.mp4"
      cap = cv2.VideoCapture(video_path)
      
      # Loop through the video frames
      while cap.isOpened():
          ret, frame = cap.read()
          if not ret:
              break
      
          # Run inference on the frame
          results = ov_model(frame)
      
          # Visualize the results on the frame
          annotated_frame = results[0].plot()
      
          # Display the annotated frame
          cv2.imshow("YOLOv8 OpenVINO Inference", annotated_frame)
      
          # Break the loop if 'q' is pressed
          if cv2.waitKey(1) & 0xFF == ord('q'):
              break
      
      # Release the video capture object and close the display window
      cap.release()
      cv2.destroyAllWindows()

      For more detailed information on exporting and using OpenVINO, please refer to our OpenVINO Integration Guide.

      Feel free to reach out if you have any more questions or need further assistance. Happy coding! 🚀

    4. Glenn JocherUltralytics(editado)

      To use Intel GPUs for inference, export your YOLOv8 model to OpenVINO format with model.export(format="openvino"), then run inference with the exported model and select the GPU with device="intel:gpu", for example ov_model("bus.jpg", device="intel:gpu"). For more details, please refer to the OpenVINO integration guide.

    5. YA12SHYAMGitHub

      ok, just to confirm i can't use ultralytics python api for inference with intel gpu like i usually do within the ultralytics ecosystem for example ?

      from ultralytics import YOLO
      model =  YOLO(path/to/model)

      here the path/to/model works with onnx, engine, opnevino;s xml , but it use cpu in case of openvino , i want to use my intel GPU

    6. Glenn JocherUltralytics(editado)

      @YA12SHYAM to use Intel GPUs with YOLOv8, export your model to OpenVINO format and select the GPU at inference with device="intel:gpu", e.g. model("bus.jpg", device="intel:gpu"). For detailed steps, refer to the OpenVINO integration guide.

  4. kanishkaswGitHub

    Hi Im getting the following error when attempting to convert the model to openVino. Tried with both 2024.1.0 and 2024.0.0. Im on ubuntu 20.04 with python 3.8 $ yolo export model=runs/classify/train/weights/best.pt format=openvino Ultralytics YOLOv8.2.31 🚀 Python-3.8.10 torch-2.3.1+cu121 CPU (Intel Core(TM) i9-7900X 3.30GHz) YOLOv8n-cls summary (fused): 73 layers, 1438723 parameters, 0 gradients, 3.3 GFLOPs

    PyTorch: starting from 'runs/classify/train/weights/best.pt' with input shape (1, 3, 320, 320) BCHW and output shape(s) (1, 3) (2.8 MB) OpenVINO: export failure ❌ 0.0s: module 'openvino' has no attribute 'version' Traceback (most recent call last): File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/bin/yolo", line 8, in sys.exit(entrypoint()) File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/cfg/init.py", line 591, in entrypoint getattr(model, mode)(**overrides) # default args from model File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/model.py", line 602, in export return Exporter(overrides=args, _callbacks=self.callbacks)(model=self.model) File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/torch/utils/_contextlib.py", line 115, in decorate_context return func(*args, **kwargs) File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/exporter.py", line 308, in call f[3], _ = self.export_openvino() File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/exporter.py", line 142, in outer_func raise e File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/exporter.py", line 137, in outer_func f, model = inner_func(*args, **kwargs) File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/exporter.py", line 454, in export_openvino LOGGER.info(f"\n{prefix} starting export with openvino {ov.version}...") AttributeError: module 'openvino' has no attribute 'version'

    1. Paula DerrengerUltralytics(editado)

      @kanishkasw hi there,

      Thank you for reaching out and providing detailed information about the issue you're encountering. It looks like you're experiencing an error when attempting to export your model to OpenVINO format. Let's work through this together.

      First, let's ensure that you are using the latest versions of torch and ultralytics. Please run the following commands to update your packages:

      pip install --upgrade torch ultralytics

      Next, it seems the error is related to the OpenVINO package. The error message module 'openvino' has no attribute '__version__' suggests there might be an issue with the OpenVINO installation. Please make sure you have a recent version of OpenVINO installed (Ultralytics requires openvino>=2024.0.0). You can install it using the following command:

      pip install -U openvino

      Once you've updated the packages, try exporting the model again:

      yolo export model=runs/classify/train/weights/best.pt format=openvino

      If the issue persists, could you please provide a minimum reproducible example? This will help us investigate the problem more effectively. You can find guidance on creating a minimum reproducible example here: Minimum Reproducible Example.

      Additionally, here's a Python example to ensure everything is set up correctly:

      from ultralytics import YOLO
      
      # Load a YOLOv8n PyTorch model
      model = YOLO("runs/classify/train/weights/best.pt")
      
      # Export the model to OpenVINO format
      model.export(format="openvino")  # creates 'best_openvino_model/'
      
      # Load the exported OpenVINO model
      ov_model = YOLO("best_openvino_model/")
      
      # Run inference
      results = ov_model("https://ultralytics.com/images/bus.jpg")

      For more detailed instructions on using OpenVINO, please refer to our OpenVINO Integration Guide.

      Feel free to reach out if you have any further questions or run into any other issues. We're here to help! 😊

  5. renato-rodrigGitHub

    hello everything is fine? I have a question about the results exposed in the article above. Is the time shown in the graphs in relation to the inference time that the model takes to return the detections or is it the time for image reading, image pre-processing and model inference? I ask this because on my computer (intel core i7 12 generation CPU) the yolov8n model ran with an inference time of 40ms and the gain from using OpenVINO was not that great.

    1. Paula DerrengerUltralytics

      @renato-rodrig hello! 👋 Regarding your question about the times shown in the graphs, they typically refer to the total inference time, which includes the actual model inference as well as the time taken for pre-processing the input data (like image reading and resizing).

      The difference you observed with OpenVINO on your Intel Core i7 may vary due to several factors such as the specific configuration of your system, the type of tasks being run, and the optimizations that the YOLOv8n model can leverage on that platform. Generally, OpenVINO tends to show more significant performance gains on integrated Intel GPUs and some specific CPU configurations.

      If you haven't seen a major performance improvement, you might want to look into further tuning your OpenVINO deployment or explore using other optimization techniques provided by OpenVINO. Additionally, ensure all drivers and software components are up to date for optimal performance.

      Here’s a quick example of ensuring you're using the model in the most optimized manner:

      from ultralytics import YOLO
      
      # Load YOLOv8n PyTorch model
      model = YOLO('yolov8n.pt')
      
      # Export the model to OpenVINO
      model.export(format='openvino')  # Creates 'yolov8n_openvino_model/'
      
      # Load the exported OpenVINO model
      ov_model = YOLO('yolov8n_openvino_model/')
      
      # Run inference to see if performance improves
      results = ov_model('https://ultralytics.com/images/bus.jpg')

      Feel free to experiment with different configurations and settings! 😊

      1
  6. YouROS12GitHub

    I wanna do inferences with my exported pre-trained yolov8 model using Raspberry PI with a Neural Network Computing 2 (NCS2) plugged in.. but its doesn't support opset 11 or above.. only opset10.. I specified onnx opset to 10 and convert it to Openvino but it didn't work.

    Anyway please to export openvino model directly in opset10 ? Does even yolov8 support this specified opset format ?

    Thank you.

    1. Glenn JocherUltralytics(editado)

      @YouROS12 the current OpenVINO export no longer goes through ONNX: Ultralytics converts the PyTorch model directly to OpenVINO IR with openvino.convert_model, so the ONNX opset argument does not apply and the old mo Model Optimizer step isn't needed. Export with:

      from ultralytics import YOLO
      
      # Load a pretrained YOLOv8 model
      model = YOLO('yolov8n.pt')
      
      # Export the model to OpenVINO
      model.export(format='openvino')  # creates 'yolov8n_openvino_model/'

      The export requires openvino>=2024.0.0. If your target requires an older OpenVINO that cannot load these models, you can still try model.export(format='onnx', opset=10) and convert the ONNX file with that toolkit's own tools, but some YOLOv8 operations may not be supported in older opsets, which could lead to errors during export or inference.

    2. YouROS12GitHub

      Where can I find documentation about YOLOv8's operations with opset 10 ? Updating OpenVINO toolkit is not an option because NCS2 works only at opset 10 and lower.

    3. Paula DerrengerUltralytics

      @YouROS12 the documentation for ONNX opset versions and the operations they support can be found on the ONNX GitHub repository or the official ONNX documentation. However, there isn't specific documentation for YOLOv8's operations with opset 10, as this would be a combination of YOLOv8's implementation details and ONNX's opset specifications.

      To check which operations are supported in opset 10, you can refer to the ONNX Operators documentation for that specific version. This documentation lists all the operators available in opset 10 and their details.

      For YOLOv8, you would need to look at the model's architecture and identify which operations are used. Then, cross-reference these operations with the ONNX opset 10 documentation to see if they are supported. If certain operations are not supported in opset 10, you might need to modify the model or the export script to use alternative operations that are compatible with opset 10.

      Since updating OpenVINO is not an option for you, if you find that YOLOv8 uses operations not supported in opset 10, you might need to consider using a different model architecture that is compatible with opset 10, or reach out to the community or Ultralytics for further assistance on how to proceed with your specific use case and hardware constraints.