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#
| Propriedade | Detalhes |
|---|---|
Argumento format | openvino |
| Saída | yolo26n_openvino_model/, um diretório com yolo26n.xml, yolo26n.bin e metadata.yaml; yolo26n_int8_openvino_model/ para uma exportação quantize=8 |
| Funciona em | CPUs 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ção | OpenVINO Runtime 2024.0.0 ou mais recente (o pacote Python openvino) |
| Precisão | FP32, 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ção | Linux, macOS ou Windows. A exportação é executada na CPU e não precisa de GPU |
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:
| Pacote | Versão necessária |
|---|---|
torch | 2.1 ou mais recente |
openvino | 2024.0.0 ou mais recente; 2025.2.0 ou mais recente no macOS 15.4 e posteriores |
nncf | 2.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.
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/'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")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#
| Argumento | Tipo | Padrão | Descrição |
|---|---|---|---|
format | str | 'openvino' | 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: 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. |
quantize | int ou str | None | Precisã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. |
data | str | None | Ficheiro 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. |
fraction | float, int ou list | 1.0 | Subconjunto 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. |
dynamic | bool | False | Torna 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. |
nms | bool, opcional | None | Seleciona a saída bruta (None, padrão), NMS integrado (True) ou a cabeça sem NMS (False). Consulte o formato de saída. |
batch | int | 1 | Tamanho 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. |
device | str | None | A 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
valdedata, ou da divisão definida comsplit. Usafractionpara 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
float32e 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=npua 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.
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:
| Ficheiro | Conteúdo |
|---|---|
yolo26n.xml | O grafo da rede no formato OpenVINO IR |
yolo26n.bin | Os pesos |
metadata.yaml | Nomes 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:
device | Dispositivo OpenVINO |
|---|---|
| sem definir | AUTO, 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 |
cpu | CPU |
xpu ou xpu:0 | GPU ou GPU.0, a GPU Intel integrada ou dedicada. xpu:1 seleciona GPU.1 numa máquina com duas GPUs Intel |
npu | NPU, 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
imgszebatch, que Ultralytics lê demetadata.yaml. Umimgszpassado apredicté 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):predictaceita diferentes tamanhos de lote e qualquerimgszque 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
LATENCYdo OpenVINO e executa a inferência de forma síncrona. Para processar muitos pedidos em paralelo com a indicaçãoTHROUGHPUT, 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#
- Modos de latência e débito do OpenVINO: escolhe entre a menor latência para um fluxo e o maior débito para muitos.
- Intel DL Streamer: executa modelos exportados em pipelines de análise de vídeo GStreamer em CPUs, GPUs e NPUs Intel Core Ultra.
- Dispositivos de inferência OpenVINO: os dispositivos CPU, GPU e NPU e o modo
AUTOna documentação do OpenVINO. - Notebooks OpenVINO: notebooks tutoriais da Intel, incluindo otimização YOLO26.
Limitações e solução de problemas#
- Versão do PyTorch: a exportação falha com
OpenVINO export requires torch>=2.1em 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.0e atualiza um pacote mais antigo. - Checkpoints treinados com
quantize=8: um checkpoint ajustado com treino com reconhecimento da quantização falha comformat='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 comquantize=8, ou exporta o checkpoint ajustado para ONNX ou TensorRT. - Exportação INT8 sem
data: a exportação registaINT8 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. Passadatacom 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.yamltem 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 dequantize,imgsz,dynamic,nmsoubatch, pelo que a exportação seguinte substitui a anterior. Todas as exportações INT8, com ou semdevice=npu, partilhamyolo26n_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.(ouUsing '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=npupara a usar: sedevicenão estiver definido, a NPU não é selecionada. - Formas dinâmicas com NMS: uma exportação com
dynamic=Trueenms=Trueregista'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'.quandobatchpermanece definido como1. Ultralytics executa lotes maiores em blocos do tamanho do lotebatchda 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
CPUouAUTOcom o tamanho de loteimgszda exportação, tal como faz com um modelo estático: umimgszpassado apredictouvalé ignorado, evalusa obatchda exportação.predictcontinua 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_ISAantes de carregar o modelo para usar outro limite. - Linux em ARM64: Ultralytics executa o dispositivo
CPUno modo de execução de precisão do OpenVINO, com precisão de inferência FP32. - NMS incorporado:
nms=Truegera'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=Falserequer um modelo com cabeça sem NMS, como YOLO26 ou YOLOv10. Para outros modelos, por exemplo, YOLO11, a exportação exibe o avisoThis 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.
| Modelo | imgsz | PyTorch | OpenVINO FP32 | OpenVINO FP16 | OpenVINO INT8 |
|---|---|---|---|---|---|
| YOLO26n | 640 | 13.31 | 3.41 | 3.33 | 3.35 |
| YOLO26s | 640 | 24.28 | 5.18 | 5.18 | 4.51 |
| YOLO26m | 640 | 49.94 | 8.39 | 8.34 | 6.60 |
| YOLO26l | 640 | 63.75 | 10.92 | 11.05 | 8.94 |
| YOLO26x | 640 | 115.11 | 17.12 | 17.16 | 12.83 |
YOLO26n nas mesmas 8 CPUs (PyTorch e OpenVINO ambos associados às CPUs 0-7 desse servidor com taskset):
| Métrica | PyTorch | OpenVINO FP32 | OpenVINO FP16 | OpenVINO INT8 |
|---|---|---|---|---|
| Latência (ms/imagem) | 9.28 | 7.13 | 7.14 | 6.71 |
| mAPval 50-95 | 40.8 | 40.9 | 40.9 | 40.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.
| Modelo | CPU PyTorch | CPU FP32 | CPU FP16 | CPU INT8 | GPU FP32 | GPU FP16 | GPU INT8 | NPU FP32 | NPU FP16 | NPU INT8 |
|---|---|---|---|---|---|---|---|---|---|---|
| YOLO26n | 29.28 | 14.35 | 14.23 | 9.99 | 4.09 | 4.03 | 4.24 | 7.68 | 7.71 | 8.60 |
| YOLO26s | 59.32 | 35.03 | 33.55 | 16.68 | 5.08 | 5.14 | 4.47 | 9.89 | 9.94 | 10.69 |
| YOLO26m | 143.21 | 90.53 | 88.82 | 33.33 | 7.10 | 7.06 | 5.61 | 13.02 | 13.13 | 14.84 |
| YOLO26l | 181.16 | 112.83 | 111.31 | 43.27 | 8.45 | 8.49 | 6.25 | 14.53 | 14.55 | 15.64 |
| YOLO26x | 379.75 | 241.21 | 236.87 | 78.92 | 13.03 | 12.98 | 8.74 | 23.48 | 23.41 | 21.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.
| Modelo | CPU PyTorch | CPU FP32 | CPU FP16 | CPU INT8 | GPU FP32 | GPU FP16 | GPU INT8 | NPU FP32 | NPU FP16 | NPU INT8 |
|---|---|---|---|---|---|---|---|---|---|---|
| YOLO26n | 27.33 | 16.84 | 16.73 | 8.62 | 3.33 | 3.34 | 3.46 | 23.71 | 23.70 | 23.96 |
| YOLO26s | 60.20 | 54.71 | 54.45 | 20.19 | 4.66 | 4.65 | 3.99 | 26.62 | 26.62 | 25.89 |
| YOLO26m | 152.87 | 178.59 | 179.25 | 53.07 | 9.03 | 8.98 | 5.70 | 32.94 | 33.01 | 30.95 |
| YOLO26l | 201.57 | 238.15 | 233.70 | 67.73 | 11.32 | 11.36 | 7.45 | 36.02 | 35.77 | 32.64 |
| YOLO26x | 431.04 | 567.22 | 561.39 | 151.11 | 19.08 | 19.63 | 13.69 | 49.64 | 49.69 | 41.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.
| Modelo | CPU PyTorch | CPU FP32 | CPU FP16 | CPU INT8 | GPU FP32 | GPU FP16 | GPU INT8 |
|---|---|---|---|---|---|---|---|
| YOLO26n | 33.19 | 13.43 | 13.20 | 11.40 | 9.13 | 9.07 | 5.79 |
| YOLO26s | 70.92 | 36.16 | 36.07 | 15.54 | 16.37 | 16.65 | 9.27 |
| YOLO26m | 192.45 | 102.52 | 101.88 | 35.72 | 34.47 | 35.71 | 15.46 |
| YOLO26l | 239.19 | 129.24 | 128.50 | 45.38 | 43.24 | 43.40 | 19.72 |
| YOLO26x | 511.89 | 293.40 | 296.48 | 85.24 | 79.49 | 79.45 | 34.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=npuselecionar 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.
Assista: Como exportar Ultralytics YOLO26 para o formato Intel OpenVINO para acelerar a inferência 🚀
Perguntas frequentes#
Sim, na CPU. O dispositivo
CPUdo 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 dispositivosGPUeNPUprecisam de hardware Intel; por isso,device=xpuedevice=npurecorrem 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 semdevice=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=Truee passe o lote e oimgsznecessá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âmicafrom 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 pixelsUse OpenVINO quando o hardware de implantação for Intel:
device=xpuedevice=npuselecionam 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.
Heyujie96
how can i export a trained cls or obb kind model to openvino kind
EduardoNew
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.appimage 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?
Glenn JocherUltralytics(editado)@EduardoNew the exit code 0xC0000005 often indicates a memory access violation. Let's address this step-by-step:
-
Path Format: Try using forward slashes in your OpenVINO model path:
"yolov8n_openvino_model/"instead of backslashes. -
OpenVINO Version: Ultralytics requires
openvino>=2024.0.0. Try upgrading to a recent release:
pip install -U openvino- 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!
-
Ranjith3436
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.
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.
Ranjith3436
how do i can know about model's ability?
Glenn JocherUltralyticsTo 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.
kimchi2020
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
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
-
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/' -
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! 🚀
-
kimchi2020
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
Glenn JocherUltralyticsHi @kimchi2020,
Thank you for reaching out! The error you're encountering seems to be related to a circular import issue with the
torchvisionlibrary. This can happen if there's a naming conflict or an import loop in your code.Steps to Resolve the Issue:
-
Check for Naming Conflicts: Ensure that your script name (
onnx.py) is not conflicting with any library names. Rename your script to something unique, likerun_inference.py. -
Verify Installation: Make sure you have the latest versions of
torch,torchvision, andultralyticsinstalled. You can update them using:pip install --upgrade torch torchvision ultralytics -
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! 🚀
-
YA12SHYAM
Hi @glenn-jocher , what if i want to use intel GPU's for the inference, using device=GPU doesn't seems to works , it looks for cuda i.e nvidia gpu
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 withdevice="intel:gpu", for exampleov_model("bus.jpg", device="intel:gpu"). For more details, please refer to the OpenVINO integration guide.YA12SHYAM
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
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.
kanishkasw
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'
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
torchandultralytics. Please run the following commands to update your packages:pip install --upgrade torch ultralyticsNext, 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 requiresopenvino>=2024.0.0). You can install it using the following command:pip install -U openvinoOnce you've updated the packages, try exporting the model again:
yolo export model=runs/classify/train/weights/best.pt format=openvinoIf 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! 😊
renato-rodrig
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.
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
YouROS12
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.
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 ONNXopsetargument does not apply and the oldmoModel 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 trymodel.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.YouROS12
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.
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.
