Link to this sectionExportação para Intel OpenVINO#

Neste guia, abordamos a exportação de modelos YOLO26 para o formato OpenVINO, que pode proporcionar até 3x de aceleração em CPU, além de acelerar a inferência YOLO em hardware de GPU e NPU da Intel.

OpenVINO, abreviação de Open Visual Inference & Neural Network Optimization toolkit, é um kit de ferramentas abrangente para otimizar e implantar modelos de inferência de IA. Embora o nome contenha Visual, o OpenVINO também suporta várias tarefas adicionais, incluindo linguagem, áudio, séries temporais, etc.

Link to this sectionExemplos de Uso#

O formato OpenVINO suporta os modos Export, Predict e Validate. Exporte seu modelo e, em seguida, carregue o modelo exportado para executar a inferência ou validar sua precisão em CPU, GPU integrada/discreta ou NPU da Intel.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to OpenVINO format
model.export(format="openvino")  # creates 'yolo26n_openvino_model/'

from ultralytics import YOLO

# Load the exported OpenVINO model
model = YOLO("yolo26n_openvino_model/")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

# Run inference on a specific device, available devices: ["intel:gpu", "intel:npu", "intel:cpu"]
results = model("https://ultralytics.com/images/bus.jpg", device="intel:gpu")

from ultralytics import YOLO

# Load the exported OpenVINO model
model = YOLO("yolo26n_openvino_model/")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Link to this sectionArgumentos de Exportação#

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

Link to this sectionBenefícios do OpenVINO#

1. Desempenho: O OpenVINO oferece inferência de alto desempenho utilizando a potência de CPUs Intel, GPUs integradas e discretas, e FPGAs.
2. Suporte para Execução Heterogênea: O OpenVINO fornece uma API para escrever uma vez e implantar em qualquer hardware Intel suportado (CPU, GPU, FPGA, VPU, etc.).
3. Otimizador de Modelo: O OpenVINO fornece um Otimizador de Modelo que importa, converte e otimiza modelos de estruturas populares de deep learning como PyTorch, TensorFlow, TensorFlow Lite, Keras, ONNX, PaddlePaddle e Caffe.
4. Facilidade de Uso: O kit de ferramentas vem com uma grande coleção de notebooks de tutoriais (incluindo otimização YOLO26) ensinando diferentes aspectos do kit de ferramentas.

Link to this sectionEstrutura de Exportação OpenVINO#

Ao exportar um modelo para o formato OpenVINO, o resultado é um diretório contendo o seguinte:

1. Arquivo XML: Descreve a topologia da rede.
2. Arquivo BIN: Contém os dados binários de pesos e vieses.
3. Arquivo de mapeamento: Contém o mapeamento dos tensores de saída do modelo original para os nomes dos tensores do OpenVINO.

Você pode usar esses arquivos para executar a inferência com o OpenVINO Inference Engine.

Link to this sectionUsando a Exportação OpenVINO na Implantação#

Uma vez que seu modelo é exportado com sucesso para o formato OpenVINO, você tem duas opções principais para executar a inferência:

1. Use o pacote ultralytics, que fornece uma API de alto nível e encapsula o OpenVINO Runtime.

2. Use o pacote nativo openvino para um controle mais avançado ou personalizado sobre o comportamento da inferência.

Link to this sectionInferência com Ultralytics#

O pacote ultralytics permite que você execute facilmente a inferência usando o modelo OpenVINO exportado através do método predict. Você também pode especificar o dispositivo de destino (por exemplo, intel:gpu, intel:npu, intel:cpu) usando o argumento device.

from ultralytics import YOLO

# Load the exported OpenVINO model
ov_model = YOLO("yolo26n_openvino_model/")  # the path of your exported OpenVINO model
# Run inference with the exported model
ov_model.predict(device="intel:gpu")  # specify the device you want to run inference on

Essa abordagem é ideal para prototipagem rápida ou implantação quando você não precisa de controle total sobre o pipeline de inferência.

Link to this sectionInferência com OpenVINO Runtime#

O OpenVINO Runtime fornece uma API unificada para inferência em todo o hardware Intel suportado. Ele também oferece recursos avançados como balanceamento de carga em hardware Intel e execução assíncrona. Para obter mais informações sobre como executar a inferência, consulte os notebooks do YOLO26.

Lembre-se de que você precisará dos arquivos XML e BIN, bem como de quaisquer configurações específicas da aplicação, como tamanho de entrada, fator de escala para normalização, etc., para configurar e usar corretamente o modelo com o Runtime.

Em sua aplicação de implantação, você normalmente seguiria estes passos:

1. Inicialize o OpenVINO criando core = Core().
2. Carregue o modelo usando o método core.read_model().
3. Compile o modelo usando a função core.compile_model().
4. Prepare a entrada (imagem, texto, áudio, etc.).
5. Execute a inferência usando compiled_model(input_data).

Para passos mais detalhados e trechos de código, consulte a documentação do OpenVINO ou o tutorial da API.

Link to this sectionBenchmarks do YOLO26 com OpenVINO#

A equipe da Ultralytics avaliou o YOLO26 em vários formatos de modelo e precision, avaliando velocidade e precisão em diferentes dispositivos Intel compatíveis com o OpenVINO.

Link to this sectionIntel® Core™ Ultra#

A série Intel® Core™ Ultra™ representa um novo benchmark em computação de alto desempenho, projetada para atender às demandas crescentes dos usuários modernos — desde jogadores e criadores até profissionais que utilizam IA. Esta linha de próxima geração é mais do que uma série de CPUs tradicionais; ela combina núcleos de CPU poderosos, recursos de GPU integrada de alto desempenho e uma Unidade de Processamento Neural (NPU) dedicada dentro de um único chip, oferecendo uma solução unificada para diversas e intensas cargas de trabalho computacionais.

No coração da arquitetura Intel® Core Ultra™ está um design híbrido que permite um desempenho excepcional em tarefas de processamento tradicionais, cargas de trabalho aceleradas por GPU e operações orientadas por IA. A inclusão da NPU aprimora a inferência de IA no dispositivo, permitindo um aprendizado de máquina e processamento de dados mais rápidos e eficientes em uma ampla gama de aplicações.

A família Core Ultra™ inclui vários modelos adaptados para diferentes necessidades de desempenho, com opções que variam de designs energeticamente eficientes a variantes de alta potência marcadas pela designação "H" — ideal para laptops e fatores de forma compactos que exigem sério poder computacional. Em toda a linha, os usuários se beneficiam da sinergia da integração de CPU, GPU e NPU, proporcionando notável eficiência, capacidade de resposta e recursos multitarefa.

Como parte da inovação contínua da Intel, a série Core Ultra™ estabelece um novo padrão para a computação preparada para o futuro. Com vários modelos disponíveis e mais por vir, esta série ressalta o compromisso da Intel em oferecer soluções de ponta para a próxima geração de dispositivos inteligentes aprimorados por IA.

Os benchmarks abaixo foram executados no Intel® Core™ Ultra™ X7 358H, Intel® Core™ Ultra™ 7 258V e Intel® Core™ Ultra™ 7 155H nas precisões FP32, FP16 e INT8.

Link to this sectionIntel® Core™ Ultra™ X7 358H#

Benchmarks

GPU Intel® Arc™ integradaIntel® Panther Lake CPUIntegrated Intel® AI Boost NPU

Resultados Detalhados do Benchmark

Modelo	Formato	Precisão	Status	Tamanho (MB)	metrics/mAP50-95(B)	Tempo de inferência (ms/im)
YOLO26n	PyTorch (CPU)	FP32	✅	5.3	0.4765	25.18
YOLO26n	OpenVINO	FP32	✅	9.6	0.4763	2.67
YOLO26n	OpenVINO	FP16	✅	5.1	0.4763	2.64
YOLO26n	OpenVINO	INT8	✅	3.2	0.4625	2.73
YOLO26s	PyTorch (CPU)	FP32	✅	19.5	0.5703	50.09
YOLO26s	OpenVINO	FP32	✅	36.7	0.5615	3.57
YOLO26s	OpenVINO	FP16	✅	18.6	0.5615	3.55
YOLO26s	OpenVINO	INT8	✅	10.0	0.547	3.09
YOLO26m	PyTorch (CPU)	FP32	✅	42.2	0.6196	135.1
YOLO26m	OpenVINO	FP32	✅	78.3	0.6168	5.64
YOLO26m	OpenVINO	FP16	✅	39.5	0.6168	5.85
YOLO26m	OpenVINO	INT8	✅	20.5	0.5994	4.14
YOLO26l	PyTorch (CPU)	FP32	✅	50.7	0.6215	169.75
YOLO26l	OpenVINO	FP32	✅	95.3	0.6206	8.14
YOLO26l	OpenVINO	FP16	✅	48.1	0.6206	8.18
YOLO26l	OpenVINO	INT8	✅	25.2	0.5999	4.67
YOLO26x	PyTorch (CPU)	FP32	✅	113.2	0.6512	407.56
YOLO26x	OpenVINO	FP32	✅	213.2	0.6569	13.11
YOLO26x	OpenVINO	FP16	✅	107.1	0.6569	13.15
YOLO26x	OpenVINO	INT8	✅	54.8	0.6374	9.24

Link to this sectionIntel® Core™ Ultra™ 7 258V#

Benchmarks

GPU Intel® Arc™ integradaIntel® Lunar Lake CPUIntegrated Intel® AI Boost NPU

Resultados Detalhados do Benchmark

Modelo	Formato	Precisão	Status	Tamanho (MB)	metrics/mAP50-95(B)	Tempo de inferência (ms/im)
YOLO26n	PyTorch (CPU)	FP32	✅	5.3	0.4765	31.43
YOLO26n	OpenVINO	FP32	✅	9.6	0.4762	3.57
YOLO26n	OpenVINO	FP16	✅	5.1	0.4762	3.53
YOLO26n	OpenVINO	INT8	✅	3.2	0.4625	3.65
YOLO26s	PyTorch (CPU)	FP32	✅	19.5	0.5703	60.4
YOLO26s	OpenVINO	FP32	✅	36.7	0.5616	5.02
YOLO26s	OpenVINO	FP16	✅	18.6	0.5616	5.01
YOLO26s	OpenVINO	INT8	✅	10.0	0.547	4.31
YOLO26m	PyTorch (CPU)	FP32	✅	42.2	0.6196	173.31
YOLO26m	OpenVINO	FP32	✅	78.3	0.6191	9.48
YOLO26m	OpenVINO	FP16	✅	39.5	0.6168	9.6
YOLO26m	OpenVINO	INT8	✅	20.5	0.5994	6.03
YOLO26l	PyTorch (CPU)	FP32	✅	50.7	0.6173	224.52
YOLO26l	OpenVINO	FP32	✅	95.3	0.3725	11.88
YOLO26l	OpenVINO	FP16	✅	48.1	0.6201	12.0
YOLO26l	OpenVINO	INT8	✅	25.2	0.5999	8.47
YOLO26x	PyTorch (CPU)	FP32	✅	113.2	0.6512	595.72
YOLO26x	OpenVINO	FP32	✅	213.2	0.6567	20.26
YOLO26x	OpenVINO	FP16	✅	107.1	0.6454	20.25
YOLO26x	OpenVINO	INT8	✅	54.8	0.6374	14.77

Link to this sectionIntel® Core™ Ultra™ 7 155H#

Benchmarks

GPU Intel® Arc™ integradaIntel® Meteor Lake CPU

Resultados Detalhados do Benchmark

Modelo	Formato	Precisão	Status	Tamanho (MB)	metrics/mAP50-95(B)	Tempo de inferência (ms/im)
YOLO26n	PyTorch (CPU)	FP32	✅	5.3	0.4765	38.77
YOLO26n	OpenVINO	FP32	✅	9.6	0.4774	9.87
YOLO26n	OpenVINO	FP16	✅	5.1	0.4774	9.84
YOLO26n	OpenVINO	INT8	✅	3.2	0.4705	5.86
YOLO26s	PyTorch (CPU)	FP32	✅	19.5	0.5703	69.54
YOLO26s	OpenVINO	FP32	✅	36.7	0.5616	17.29
YOLO26s	OpenVINO	FP16	✅	18.6	0.5616	17.06
YOLO26s	OpenVINO	INT8	✅	10.0	0.5452	10.33
YOLO26m	PyTorch (CPU)	FP32	✅	42.2	0.6196	192.22
YOLO26m	OpenVINO	FP32	✅	78.3	0.6187	34.64
YOLO26m	OpenVINO	FP16	✅	39.5	0.6187	34.75
YOLO26m	OpenVINO	INT8	✅	20.5	0.6073	15.99
YOLO26l	PyTorch (CPU)	FP32	✅	50.7	0.6215	245.62
YOLO26l	OpenVINO	FP32	✅	95.3	0.6202	43.7
YOLO26l	OpenVINO	FP16	✅	48.1	0.6202	44.65
YOLO26l	OpenVINO	INT8	✅	25.2	0.6048	20.31
YOLO26x	PyTorch (CPU)	FP32	✅	113.2	0.6512	513.06
YOLO26x	OpenVINO	FP32	✅	213.2	0.6544	80.19
YOLO26x	OpenVINO	FP16	✅	107.1	0.6544	79.83
YOLO26x	OpenVINO	INT8	✅	54.8	0.6393	35.16

Link to this sectionReproduz os nossos resultados#

Para reproduzir os benchmarks da Ultralytics acima em todos os formatos de exportação, executa este código:

from ultralytics import YOLO

# Load a YOLO26n PyTorch model
model = YOLO("yolo26n.pt")

# Benchmark YOLO26n speed and accuracy on the COCO128 dataset for all export formats
results = model.benchmark(data="coco128.yaml")

Link to this sectionConclusão#

Os resultados do benchmarking demonstram claramente os benefícios de exportar o modelo YOLO26 para o formato OpenVINO. Em diferentes modelos e plataformas de hardware, o formato OpenVINO supera consistentemente outros formatos em termos de velocidade de inferência, mantendo uma precisão comparável.

Os benchmarks sublinham a eficácia do OpenVINO como uma ferramenta para implementar modelos de aprendizagem profunda. Ao converter modelos para o formato OpenVINO, os programadores podem obter melhorias de desempenho significativas, tornando mais fácil implementar estes modelos em aplicações do mundo real.

Para informações mais detalhadas e instruções sobre como usar o OpenVINO, consulta a documentação oficial do OpenVINO.

Link to this sectionFAQ#

Link to this sectionComo posso exportar modelos YOLO26 para o formato OpenVINO?#

Exportar modelos YOLO26 para o formato OpenVINO pode melhorar significativamente a velocidade do CPU e permitir acelerações de GPU e NPU em hardware da Intel. Para exportar, podes usar Python ou CLI como mostrado abaixo:

from ultralytics import YOLO

# Load a YOLO26n PyTorch model
model = YOLO("yolo26n.pt")

# Export the model
model.export(format="openvino")  # creates 'yolo26n_openvino_model/'

Para mais informações, consulta a documentação de formatos de exportação.

Link to this sectionQuais são os benefícios de usar o OpenVINO com modelos YOLO26?#

Usar o kit de ferramentas OpenVINO da Intel com modelos YOLO26 oferece vários benefícios:

1. Desempenho: Atinge até 3x de aceleração na inferência por CPU e aproveita GPUs e NPUs da Intel para aceleração.
2. Model Optimizer: Converte, otimiza e executa modelos de estruturas populares como PyTorch, TensorFlow e ONNX.
3. Facilidade de uso: Está disponível uma grande coleção de blocos de notas de tutoriais para ajudar os utilizadores a começar, incluindo alguns para YOLO26.
4. Execução Heterogénea: Implementa modelos em vários hardwares da Intel com uma API unificada.

Para comparações detalhadas de desempenho, visita a nossa secção de benchmarks.

Link to this sectionComo posso executar a inferência usando um modelo YOLO26 exportado para o OpenVINO?#

Após exportares um modelo YOLO26n para o formato OpenVINO, podes executar a inferência usando Python ou CLI:

from ultralytics import YOLO

# Load the exported OpenVINO model
ov_model = YOLO("yolo26n_openvino_model/")

# Run inference
results = ov_model("https://ultralytics.com/images/bus.jpg")

Consulta a nossa documentação de modo de previsão para mais detalhes.

Link to this sectionPor que devo escolher o Ultralytics YOLO26 em vez de outros modelos para a exportação OpenVINO?#

O Ultralytics YOLO26 está otimizado para deteção de objetos em tempo real com alta precisão e velocidade. Especificamente, quando combinado com o OpenVINO, o YOLO26 oferece:

• Até 3x de aceleração em CPUs Intel
• Implementação perfeita em GPUs e NPUs Intel
• Precisão consistente e comparável em vários formatos de exportação

Para uma análise de desempenho aprofundada, verifica os nossos benchmarks do YOLO26 detalhados em diferentes hardwares.

Link to this sectionPosso fazer o benchmarking de modelos YOLO26 em diferentes formatos como PyTorch, ONNX e OpenVINO?#

Sim, podes fazer o benchmarking de modelos YOLO26 em vários formatos, incluindo PyTorch, TorchScript, ONNX e OpenVINO. Usa o seguinte fragmento de código para executar benchmarks no conjunto de dados escolhido:

from ultralytics import YOLO

# Load a YOLO26n PyTorch model
model = YOLO("yolo26n.pt")

# Benchmark YOLO26n speed and [accuracy](https://www.ultralytics.com/glossary/accuracy) on the COCO8 dataset for all export formats
results = model.benchmark(data="coco8.yaml")

Para resultados detalhados de benchmarks, consulta a nossa secção de benchmarks e a documentação de formatos de exportação.