Predição de modelos com o Ultralytics YOLO
Introdução#
Em aprendizado de máquina e visão computacional, usar um modelo treinado para interpretar dados visuais é chamado de inferência ou previsão. O modo Predict do Ultralytics YOLO26 executa inferência rápida em tempo real com uma ampla variedade de fontes de dados.
Consulta a pré-visualização inédita do YOLO27 para ver exemplos de inferência planeados.
Assista: Extraia caixas delimitadoras, máscaras, pontos-chave, OBB, profundidade e muito mais com Ultralytics YOLO26 em Python 🚀
Aplicações no mundo real#
| Indústria transformadora | Desporto | Segurança |
|---|---|---|
| Deteção de peças sobresselentes de veículos | Deteção de jogadores de futebol | Deteção de quedas de pessoas |
Por que usar o Ultralytics YOLO para inferência?#
Principais motivos para usar o modo Predict do YOLO26:
- Versatilidade: Executa inferência em imagens, vídeos e transmissões ao vivo.
- Desempenho: desenvolvido para processamento em tempo real e alta velocidade, sem sacrificar a precisão.
- Facilidade de uso: interfaces intuitivas de Python e CLI para implantação e testes rápidos.
- Altamente personalizável: várias configurações e parâmetros permitem ajustar o comportamento da inferência do modelo de acordo com os teus requisitos específicos.
- Pronto para produção: implanta modelos como endpoints de inferência da Ultralytics Platform com escalabilidade automática e monitoramento, ou executa a inferência localmente.
Principais recursos do modo de predição#
O modo Predict do YOLO26 inclui:
- Compatibilidade com várias fontes de dados: O modo Predict aceita imagens individuais, coleções de imagens, arquivos de vídeo e transmissões de vídeo em tempo real.
- Modo de streaming: usa o recurso de streaming para gerar um gerador de objetos
Resultsque economiza memória. Ativa esse recurso definindostream=Trueno método de chamada do preditor. Ao contrário do comportamento padrão (stream=False), que retorna uma lista contendo todos os resultados,stream=Truefornece os resultados um de cada vez, o que é especialmente útil para vídeos longos e transmissões ao vivo. - Processamento em lotes: Processa várias imagens ou quadros de vídeo em um único lote, reduzindo ainda mais o tempo total de inferência.
- Integração facilitada: Integra-te a fluxos de dados existentes e a outros componentes de software por meio de uma API flexível.
Os modelos Ultralytics YOLO retornam uma lista Python de objetos Results ou um gerador de objetos Results que economiza memória quando stream=True é passado para o modelo durante a inferência:
from ultralytics import YOLO
# Carregar um modelo
model = YOLO("yolo26n.pt") # modelo YOLO26n pré-treinado
# Executa inferência em lote em uma lista de imagens
results = model(["image1.jpg", "image2.jpg"]) # retorna uma lista de objetos Results
# Processa a lista de resultados
for result in results:
boxes = result.boxes # Objeto Boxes para saídas de caixas delimitadoras
masks = result.masks # Objeto Masks para saídas de máscaras de segmentação
keypoints = result.keypoints # Objeto Keypoints para saídas de pose
probs = result.probs # Objeto Probs para saídas de classificação
obb = result.obb # Objeto de caixas orientadas para saídas OBB
result.show() # exibe na tela
result.save(filename="result.jpg") # salva no discoFontes de inferência#
O YOLO26 pode processar diferentes tipos de fontes de entrada para inferência, como mostra a tabela abaixo. As fontes incluem imagens estáticas, transmissões de vídeo e vários formatos de dados. A tabela também indica se cada fonte pode ser usada no modo de streaming com o argumento stream=True ✅. O modo de streaming é útil para processar vídeos ou transmissões ao vivo, pois cria um gerador de resultados em vez de carregar todos os quadros na memória.
Usa stream=True para processar vídeos longos ou grandes conjuntos de dados e gerenciar a memória com eficiência. Quando stream=False, os resultados de todos os quadros ou pontos de dados são armazenados na memória, o que pode se acumular rapidamente e causar erros de falta de memória para entradas grandes. Em contrapartida, stream=True usa um gerador que mantém na memória apenas os resultados do quadro ou ponto de dados atual, reduzindo significativamente o consumo de memória e evitando problemas de falta de memória.
| Fonte | Exemplo | Tipo | Observações |
|---|---|---|---|
| imagem | 'image.jpg' | str ou Path | Arquivo de imagem único. |
| URL | 'https://ultralytics.com/images/bus.jpg' | str | URL de uma imagem. |
| captura de tela ✅ | 'screen' | str | Capture a tela continuamente até parar. |
| PIL | Image.open('image.jpg') | PIL.Image | Formato HWC com canais RGB. |
| OpenCV | cv2.imread('image.jpg') | np.ndarray | Formato HWC com canais BGR uint8 (0-255). |
| NumPy | np.zeros((640,1280,3)) | np.ndarray | Formato HWC com canais BGR uint8 (0-255). |
| torch | torch.zeros(16,3,320,640) | torch.Tensor | Formato BCHW com canais RGB float32 (0.0-1.0). |
| CSV | 'sources.csv' | str ou Path | Arquivo CSV com caminhos para imagens, vídeos ou diretórios. |
| vídeo ✅ | 'video.mp4' | str ou Path | Arquivo de vídeo em formatos como MP4, AVI etc. |
| diretório ✅ | 'path/' | str ou Path | Caminho para um diretório com imagens ou vídeos. |
| glob ✅ | 'path/*.jpg' | str | Padrão glob para corresponder a vários arquivos. Usa o caractere * como curinga. |
| YouTube ✅ | 'https://youtu.be/LNwODJXcvt4' | str | URL de um vídeo do YouTube. |
| stream ✅ | 'rtsp://example.com/media.mp4' | str | URL para protocolos de streaming como RTSP, RTMP, TCP ou um endereço IP. |
| multi-stream ✅ | 'list.streams' | str ou Path | Arquivo de texto *.streams com uma URL de transmissão por linha; ou seja, 8 transmissões serão executadas com batch-size 8. |
| webcam ✅ | 0 | int | Índice do dispositivo de câmera conectado para executar a inferência. |
Abaixo estão exemplos de código para usar cada tipo de fonte:
Executa a inferência em um arquivo de imagem.
from ultralytics import YOLO
# Carrega um modelo YOLO26n pré-treinado
model = YOLO("yolo26n.pt")
# Define o caminho para o arquivo de imagem
source = "path/to/image.jpg"
# Executa inferência na fonte
results = model(source) # lista de objetos ResultsArgumentos de inferência#
model.predict() aceita vários argumentos que podem ser passados no momento da inferência para substituir os valores padrão:
Formato fixo vs. retângulo mínimo (rect)#
Por padrão, predict usa rect=True, que ativa o preenchimento com retângulo mínimo quando possível. A imagem é redimensionada para caber dentro de imgsz e recebe preenchimento apenas até o múltiplo de stride mais próximo, então o tensor final pode ser menor que imgsz. O preenchimento com retângulo mínimo só é usado quando todas as imagens do lote têm a mesma forma e o backend é compatível (PyTorch .pt ou uma exportação com forma dinâmica, como ONNX dinâmico). Caso contrário, as imagens recebem preenchimento até o destino imgsz completo. Os modelos Depth e RT-DETR ignoram rect e redimensionam todas as imagens para preencher o imgsz completo sem preenchimento.
Usa rect=False para usar sempre o destino imgsz completo. Isto é recomendado quando precisas de um tamanho de entrada fixo que corresponda aos modelos exportados (ONNX, TensorRT, etc.).
imgsz inteiro vs. tupla
- Um
imgsz=640inteiro se torna um destino quadrado(640, 640)após o arredondamento para stride. - Uma tupla
imgsz=(384, 672)define um destino retangular. Comrect=True, o tensor real pode ser menor que esse destino.
Treinamento vs. predict/export
O treinamento aceita apenas um imgsz inteiro (uma lista [h, w] é convertida para o maior valor). Predict e export aceitam um inteiro ou uma tupla (height, width).
from ultralytics import YOLO
# Carrega um modelo YOLO26n pré-treinado
model = YOLO("yolo26n.pt")
# Execute inferência em 'bus.jpg' com argumentos
model.predict("https://ultralytics.com/images/bus.jpg", save=True, imgsz=320, conf=0.25)Argumentos de inferência:
| Argumento | Tipo | Padrão | Descrição |
|---|---|---|---|
source | str ou int ou None | None | Especifica a origem dos dados para a inferência. Pode ser o caminho de uma imagem, um ficheiro de vídeo, um diretório, um URL ou o ID de um dispositivo para transmissões em direto. Se não for especificada, é registado um aviso e o modelo recorre aos recursos de demonstração integrados (ultralytics/assets ou um URL de demonstração para OBB). Suporta uma grande variedade de formatos e origens, permitindo uma aplicação flexível em diferentes tipos de entrada. |
conf | float | 0.25 | Define o limiar mínimo de confiança para as deteções. Os objetos detetados com confiança abaixo deste limiar são descartados. Ajustar este valor pode ajudar a reduzir os falsos positivos. |
iou | float | 0.5 | Limiar de interseção sobre união (IoU) para a supressão não máxima (NMS). Valores mais baixos resultam em menos deteções, eliminando caixas sobrepostas, o que é útil para reduzir duplicados. |
imgsz | int ou tuple | 640 | Alvo do letterbox. Um número inteiro define um N×N quadrado; uma tupla define (height, width). Com rect=True, o tensor real pode ser menor do que este alvo devido ao preenchimento em retângulo mínimo. Usa rect=False para um tamanho fixo. Consulta Formato fixo vs. retângulo mínimo. |
rect | bool | True | Se True, usa o preenchimento com retângulo mínimo quando possível (lote com formas iguais e backend compatível). Se False, usa sempre o imgsz completo. Consulta Forma fixa vs. retângulo mínimo. Ignorado para depth e modelos RT-DETR, que redimensionam as imagens para preencher o imgsz completo sem preenchimento. |
quantize | int ou str | None | Precisão de inferência: 16/"fp16" e 32/"fp32"/unset selecionam o cálculo em FP16 ou FP32 para modelos PyTorch e TorchScript (FP32 na CPU); os outros formatos usam a precisão selecionada pelo artefato e pelo ambiente de execução. Em 16, o OpenVINO ainda arredonda a entrada para FP16 no cliente e a converte de volta para FP32, sem alterar a precisão do ambiente de execução. A quantização INT8/PTQ é configurada durante a exportação e, em seguida, usada ao carregar o modelo exportado. Substitui a flag obsoleta half. |
device | str | None | Especifica o dispositivo para inferência (por exemplo, cpu, cuda:0, 0, npu ou npu:0). Permite que os usuários escolham entre CPU, uma GPU específica, NPU Huawei Ascend ou outros dispositivos de computação para executar modelos. Os modelos OpenVINO e LiteRT são executados em xpu e npu na GPU e na NPU Intel; consulte dispositivos de inferência para ver todos os formatos. |
dnn | bool | False | Se True, usa o módulo DNN do OpenCV em vez do ONNX Runtime para inferência com modelos ONNX. |
data | str | None | Caminho para um YAML de conjunto de dados (por exemplo, coco8.yaml), lido apenas para obter names e somente quando o modelo carregado não tem nomes de classe próprios: uma exportação de terceiros ou uma exportação da Ultralytics separada dos metadados que a acompanham. Caso contrário, esse modelo informa class0, class1 e assim por diante. |
batch | int | 1 | Especifica o tamanho do lote para inferência (funciona apenas quando a origem é um diretório, um arquivo de vídeo ou um arquivo .txt). Um tamanho de lote maior pode aumentar a taxa de processamento e reduzir o tempo total necessário para a inferência. |
tile | bool ou int | False | Executa inferência em blocos fixos e retorna os resultados nas coordenadas da imagem original. True usa imgsz; um inteiro positivo define o tamanho do bloco. Consulta Recorte em blocos de alta resolução. |
max_det | int | 300 | Número máximo de detecções permitido por imagem. Limita o número total de objetos que o modelo pode detectar em uma única inferência, evitando saídas excessivas em cenas densas. |
vid_stride | int | 1 | Intervalo entre quadros para entradas de vídeo. Permite ignorar quadros em vídeos para acelerar o processamento, à custa da resolução temporal. O valor 1 processa todos os quadros; valores maiores ignoram quadros. |
stream_buffer | bool | False | Determina se os quadros recebidos em fluxos de vídeo devem ser enfileirados. Se False, os quadros antigos são descartados para dar lugar aos novos (otimizado para aplicações em tempo real). Se True, os quadros novos são enfileirados em um buffer, garantindo que nenhum quadro seja ignorado, mas causando latência se o FPS da inferência for inferior ao FPS do fluxo. |
visualize | bool | False | Salva um mapa de calor de ativação de classe junto a cada predição, mostrando quais pixels elevaram as pontuações da classe prevista. Respeita conf e classes, portanto classes=[0] mapeia apenas essa classe. Disponível somente para modelos PyTorch da Ultralytics. |
augment | bool | False | Ativa o aumento em tempo de teste (TTA) para as predições, podendo melhorar a robustez da detecção à custa da velocidade de inferência. Disponível somente para modelos PyTorch da Ultralytics. |
agnostic_nms | bool | False | Ativa a Supressão Não Máxima (NMS) independente de classe, suprimindo caixas sobrepostas com pontuações menores entre classes diferentes, em vez de apenas dentro da mesma classe. Útil em cenários de detecção multiclasse nos quais a sobreposição entre classes é comum. Com a inferência sem NMS (nms=False no YOLO26 ou YOLOv10), isso apenas impede que a mesma detecção apareça com vários rótulos de classe (duplicatas com IoU=1.0) e não aplica supressão baseada em limiar de IoU entre caixas distintas. |
classes | list[int] | None | Filtra as predições para um conjunto de IDs de classe. Somente as detecções pertencentes às classes especificadas serão retornadas. Útil para priorizar objetos relevantes em tarefas de detecção multiclasse. |
retina_masks | bool | False | Retorna máscaras de segmentação em alta resolução. Quando ativado, as máscaras retornadas (masks.data) correspondem ao tamanho original da imagem. Quando desativado, elas têm o tamanho da imagem usado durante a inferência. |
embed | list[int] | None | Especifica as camadas das quais extrair vetores de características ou incorporações. Usa model.embed(source) para incorporações da penúltima camada ou model.predict(source, embed=[layer]) para selecionar camadas específicas. Útil para tarefas posteriores, como agrupamento ou busca por similaridade. Disponível somente para modelos PyTorch da Ultralytics. |
project | str | None | Nome do diretório do projeto onde as saídas da predição são salvas se save estiver ativado. Um caminho relativo é colocado em runs_dir/<task>, enquanto um caminho absoluto é usado sem alterações. |
name | str | None | Nome da execução de predição. Usado para criar um subdiretório dentro da pasta do projeto, onde as saídas das predições são armazenadas quando save está ativado. |
stream | bool | False | Ativa o processamento com uso eficiente de memória para vídeos longos ou muitas imagens, retornando um gerador de objetos Results em vez de carregar todos os quadros na memória de uma só vez. |
verbose | bool | True | Controla se os registros detalhados da inferência são exibidos no terminal, fornecendo informações em tempo real sobre o processo de predição. |
compile | bool ou str | False | Ativa a compilação de grafos torch.compile do PyTorch 2.x com backend='inductor'. Aceita True → "default", False → desativa, ou um modo em formato de string, como "default", "reduce-overhead", "max-autotune-no-cudagraphs". Se não for suportado, recorre à execução ansiosa e apresenta um aviso. |
channels_last | bool | None | Usa o formato de memória channels_last (NHWC) para inferência nativa com PyTorch. None ativa-o automaticamente em CPUs x86 com Linux e Windows compatíveis com oneDNN e PyTorch 1.13 ou mais recente; False desativa-o; e True solicita-o em dispositivos CPU x86 ou CUDA compatíveis. ARM64, MPS, versões mais antigas do PyTorch, CPUs sem oneDNN e formatos exportados, como TensorRT e ONNX, permanecem inalterados. |
nms | bool, opcional | None | Executa inferência de um para muitos com NMS por padrão (None ou True). Define False para usar a cabeça de um para um sem NMS quando disponível. Consulte o guia de detecção de ponta a ponta para obter detalhes. |
Argumentos de visualização:
| Argumento | Tipo | Padrão | Descrição |
|---|---|---|---|
show | bool | False | Se True, exibe as imagens ou os vídeos anotados em uma janela. Útil para obter feedback visual imediato durante o desenvolvimento ou os testes. |
save | bool | False or True | Ativa o salvamento das imagens ou dos vídeos anotados em arquivos. Útil para documentação, análises adicionais ou compartilhamento de resultados. O padrão é True ao usar a CLI e False ao usar Python. |
save_frames | bool | False | Ao processar vídeos, salva os quadros individuais como imagens. Útil para extrair quadros específicos ou fazer uma análise detalhada quadro a quadro. |
save_txt | bool | False | Salva os resultados da detecção em um arquivo de texto, seguindo o formato [class] [x_center] [y_center] [width] [height] [confidence]. Útil para integração com outras ferramentas de análise. |
save_conf | bool | False | Inclui pontuações de confiança nos arquivos de texto salvos. Aumenta o nível de detalhe disponível para pós-processamento e análise. |
save_crop | bool | False | Salva imagens recortadas das detecções. Útil para aumento de dados, análise ou criação de conjuntos de dados específicos para determinados objetos. |
show_labels | bool | True | Exibe os rótulos de cada detecção na saída visual. Permite identificar imediatamente os objetos detectados. |
show_conf | bool | True | Exibe a pontuação de confiança de cada detecção junto ao rótulo. Mostra o grau de certeza do modelo em cada detecção. |
show_boxes | bool | True | Desenha caixas delimitadoras ao redor dos objetos detectados. Essencial para identificar visualmente e localizar objetos em imagens ou quadros de vídeo. |
line_width | int or None | None | Especifica a espessura das linhas das caixas delimitadoras. Se None, a espessura da linha é ajustada automaticamente com base no tamanho da imagem. Permite personalizar a visualização para melhorar a clareza. |
Dispositivos de inferência#
device aceita nomes de dispositivos PyTorch para todos os formatos de modelo, portanto, o mesmo valor seleciona o mesmo hardware, quer você execute um checkpoint .pt ou um modelo exportado. Deixe sem definir para usar o melhor dispositivo disponível. Cada ambiente de execução associa o nome ao próprio hardware, e validação e avaliação de desempenho aceitam os mesmos valores:
| Formato | sem definir | cpu | 0 ou cuda:0 | mps | xpu | npu |
|---|---|---|---|---|---|---|
PyTorch .pt, TorchScript | GPU CUDA; caso contrário, CPU | CPU | GPU NVIDIA | GPU Apple | GPU Intel | NPU Huawei Ascend |
| ONNX | GPU CUDA; caso contrário, CPU | CPU | GPU NVIDIA (CUDA), GPU AMD (MIGraphX) | Core ML | - | - |
| TensorRT | GPU NVIDIA | GPU NVIDIA | GPU NVIDIA | - | - | - |
| OpenVINO | OpenVINO AUTO | CPU Intel | - | - | GPU Intel (xpu:1 é OpenVINO GPU.1) | NPU Intel |
| LiteRT | CPU | CPU | - | - | GPU Intel por meio do plugin OpenVINO | NPU Intel por meio do plugin OpenVINO |
| PaddlePaddle | GPU CUDA; caso contrário, CPU | CPU | GPU NVIDIA | - | - | - |
- significa que o ambiente de execução não tem um backend para esse dispositivo. ONNX, TensorRT e PaddlePaddle verificam primeiro o nome com PyTorch, portanto, rejeitam um dispositivo que o PyTorch não reconhece e, caso contrário, usam o hardware padrão. OpenVINO avisa e recorre a AUTO quando um dispositivo Intel solicitado não está disponível, e o plugin Intel LiteRT recorre à CPU. Os outros formatos escolhem o próprio hardware: CoreML é executado no Apple Neural Engine e na CPU, Edge TPU aceita tpu:0, NCNN aceita vulkan:0 para o caminho de GPU Vulkan, e os formatos restantes são executados na CPU ou no acelerador do dispositivo de destino. Os nomes antigos intel:cpu, intel:gpu e intel:npu ainda funcionam como aliases obsoletos para cpu, xpu e npu.
from ultralytics import YOLO
model = YOLO("yolo26n_openvino_model/")
results = model("https://ultralytics.com/images/bus.jpg", device="npu") # NPU IntelFormatos de imagem e vídeo#
YOLO26 é compatível com vários formatos de imagem e vídeo, conforme especificado em ultralytics/data/utils.py. Consulte as tabelas abaixo para ver os sufixos válidos e exemplos de comandos predict.
Imagens#
A tabela abaixo contém formatos de imagem válidos do Ultralytics.
Os formatos HEIC/HEIF exigem pi-heif, que é instalado automaticamente no primeiro uso. O Pillow oferece suporte nativo a AVIF.
| Sufixos de imagem | Exemplo de comando predict | Referência |
|---|---|---|
.avif | yolo predict source=image.avif | Formato de arquivo de imagem AV1 |
.bmp | yolo predict source=image.bmp | Formato de arquivo BMP da Microsoft |
.dng | yolo predict source=image.dng | Adobe DNG |
.heic | yolo predict source=image.heic | Formato de imagem de alta eficiência |
.heif | yolo predict source=image.heif | Formato de imagem de alta eficiência |
.jp2 | yolo predict source=image.jp2 | JPEG 2000 |
.jpeg | yolo predict source=image.jpeg | JPEG |
.jpg | yolo predict source=image.jpg | JPEG |
.mpo | yolo predict source=image.mpo | Objeto de várias imagens |
.png | yolo predict source=image.png | Gráficos de rede portáteis |
.tif | yolo predict source=image.tif | Formato de arquivo de imagem com tags |
.tiff | yolo predict source=image.tiff | Formato de arquivo de imagem com tags |
.webp | yolo predict source=image.webp | WebP |
Vídeos#
A tabela abaixo contém formatos de vídeo válidos do Ultralytics.
| Sufixos de vídeo | Exemplo de comando predict | Referência |
|---|---|---|
.asf | yolo predict source=video.asf | Formato de sistemas avançados |
.avi | yolo predict source=video.avi | Entrelaçamento de áudio e vídeo |
.gif | yolo predict source=video.gif | Formato de intercâmbio de gráficos |
.m4v | yolo predict source=video.m4v | MPEG-4 Parte 14 |
.mkv | yolo predict source=video.mkv | Matroska |
.mov | yolo predict source=video.mov | Formato de arquivo QuickTime |
.mp4 | yolo predict source=video.mp4 | MPEG-4 Parte 14 - Wikipedia |
.mpeg | yolo predict source=video.mpeg | MPEG-1 Parte 2 |
.mpg | yolo predict source=video.mpg | MPEG-1 Parte 2 |
.ts | yolo predict source=video.ts | Fluxo de transporte MPEG |
.wmv | yolo predict source=video.wmv | Windows Media Video |
.webm | yolo predict source=video.webm | Projeto WebM |
Trabalhando com Results#
Todas as chamadas predict() do Ultralytics retornam uma lista de objetos Results:
from ultralytics import YOLO
# Carrega um modelo YOLO26n pré-treinado
model = YOLO("yolo26n.pt")
# Executa a inferência numa imagem
results = model("https://ultralytics.com/images/bus.jpg")
results = model(
[
"https://ultralytics.com/images/bus.jpg",
"https://ultralytics.com/images/zidane.jpg",
]
) # inferência em lotesOs objetos Results têm os seguintes atributos:
| Atributo | Tipo | Descrição |
|---|---|---|
orig_img | np.ndarray | A imagem original como um array NumPy. |
orig_shape | tuple | O formato da imagem original no formato (altura, largura). |
boxes | Boxes, optional | Um objeto Boxes que contém as caixas delimitadoras das detecções. |
masks | Masks, optional | Um objeto Masks que contém as máscaras das detecções. |
probs | Probs, optional | Um objeto Probs que contém as probabilidades de cada classe para a tarefa de classificação. |
keypoints | Keypoints, optional | Um objeto Keypoints que contém os pontos-chave detectados de cada objeto. |
obb | OBB, optional | Um objeto OBB que contém caixas delimitadoras orientadas. |
semantic_mask | SemanticMask, optional | Um objeto SemanticMask que contém um mapa de classes denso por pixel. |
depth | DepthMap, optional | Um objeto DepthMap que contém um mapa de profundidade denso por pixel. |
speed | dict | Um dicionário com as velocidades de pré-processamento, inferência e pós-processamento em milissegundos por imagem. |
names | dict | Um dicionário que mapeia os índices de classe para os nomes das classes. |
path | str | O caminho para o arquivo de imagem. |
save_dir | str, optional | Diretório para salvar os resultados. |
Resultados por tarefa#
Os campos abaixo preenchidos dependem da tarefa do teu modelo — compara detecção, segmentação, segmentação semântica, estimativa de profundidade, classificação, pose e OBB se ainda não escolheste uma. Cada previsão retorna um objeto Results por imagem ou frame. Os campos comuns acima estão sempre disponíveis, enquanto os dados de previsão específicos da tarefa são armazenados nos campos abaixo. Os tensores de coordenadas e confiança do YOLO são torch.float32; os tensores de probabilidade são torch.float32, exceto quando o modelo é executado em FP16 (quantize=16 com um modelo PyTorch ou TorchScript fora da CPU, ou um modelo ONNX com entradas FP16), caso em que são torch.float16. Depois de result.numpy(), os tensores tornam-se arrays NumPy com tipos de dados NumPy correspondentes. As máscaras de instância são tensores binários torch.uint8, enquanto as máscaras semânticas usam o menor tipo inteiro prático para os IDs de classe: torch.uint8, torch.int16 ou torch.int32, dependendo da quantidade de classes.
| Atributo | Tipo | Formato | Descrição |
|---|---|---|---|
result.boxes | Boxes | (N) | Caixas de detecção. |
result.boxes.data | torch.float32 | (N,6/7) | [x1,y1,x2,y2,conf,cls] brutos, além do ID de rastreamento opcional. |
result.boxes.xyxy | torch.float32 | (N,4) | Caixas de pixels xyxy. |
result.boxes.conf | torch.float32 | (N,) | Pontuações de confiança. |
result.boxes.cls | torch.float32 | (N,) | IDs de classe; converta para int para obter os nomes. |
Os objetos Results têm os seguintes métodos:
| Método | Tipo devolvido | Descrição |
|---|---|---|
update() | None | Atualiza o objeto Results com novos dados, como caixas, máscaras, probabilidades, OBB, pontos-chave, máscaras semânticas ou profundidade. |
cpu() | Results | Retorna uma cópia do objeto Results com todos os tensores movidos para a memória da CPU. |
numpy() | Results | Retorna uma cópia do objeto Results com todos os tensores convertidos em arrays NumPy. |
cuda() | Results | Retorna uma cópia do objeto Results com todos os tensores movidos para a memória da GPU. |
to() | Results | Retorna uma cópia do objeto Results com os tensores movidos para o dispositivo e o tipo de dados especificados. |
new() | Results | Cria um novo objeto Results com os mesmos atributos de imagem, caminho, nomes e velocidade. |
plot() | np.ndarray | Plota os resultados da detecção em uma imagem BGR de entrada e retorna a imagem anotada. |
show() | None | Exibe a imagem com os resultados da inferência anotados. |
save() | str | Salva em um arquivo a imagem com os resultados da inferência anotados e retorna o nome do arquivo. |
verbose() | str | Retorna uma string de log para cada tarefa, detalhando os resultados da detecção e da classificação. |
save_txt() | str | Salva os resultados da detecção em um arquivo de texto e retorna o caminho do arquivo salvo. |
save_crop() | None | Salva as imagens recortadas das detecções no diretório especificado. |
summary() | List[Dict[str, Any]] | Converte os resultados da inferência em um dicionário resumido, com normalização opcional. |
to_df() | DataFrame | Converte os resultados da detecção em um DataFrame do Polars. |
to_csv() | str | Converte os resultados da detecção para o formato CSV. |
to_json() | str | Converte os resultados da detecção para o formato JSON. |
Para mais detalhes, consulta a documentação da classe Results.
Caixas#
O objeto Boxes pode ser usado para indexar, manipular e converter caixas delimitadoras em diferentes formatos.
from ultralytics import YOLO
# Carrega um modelo YOLO26n pré-treinado
model = YOLO("yolo26n.pt")
# Executa a inferência numa imagem
results = model("https://ultralytics.com/images/bus.jpg") # lista de resultados
# Ver resultados
for r in results:
print(r.boxes) # imprima o objeto Boxes que contém as caixas delimitadoras das detecçõesVeja uma tabela com os métodos e as propriedades da classe Boxes, incluindo nome, tipo e descrição:
| Nome | Tipo | Descrição |
|---|---|---|
cpu() | Método | Move o objeto para a memória da CPU. |
numpy() | Método | Converte o objeto em um array NumPy. |
cuda() | Método | Move o objeto para a memória CUDA. |
to() | Método | Move o objeto para o dispositivo especificado. |
xyxy | Propriedade (torch.Tensor) | Retorna as caixas no formato xyxy. |
conf | Propriedade (torch.Tensor) | Retorna os valores de confiança das caixas. |
cls | Propriedade (torch.Tensor) | Retorna os valores de classe das caixas. |
id | Propriedade (torch.Tensor) | Retorna os IDs de rastreamento das caixas (se disponíveis). |
xywh | Propriedade (torch.Tensor) | Retorna as caixas no formato xywh. |
xyxyn | Propriedade (torch.Tensor) | Retorna as caixas no formato xyxy, normalizadas pelo tamanho da imagem original. |
xywhn | Propriedade (torch.Tensor) | Retorna as caixas no formato xywh, normalizadas pelo tamanho da imagem original. |
Para mais detalhes, consulta a documentação da classe Boxes.
Máscaras#
O objeto Masks pode ser usado para indexar, manipular e converter máscaras em segmentos.
from ultralytics import YOLO
# Carregue um modelo YOLO26n-seg Segment pré-treinado
model = YOLO("yolo26n-seg.pt")
# Executa a inferência numa imagem
results = model("https://ultralytics.com/images/bus.jpg") # lista de resultados
# Ver resultados
for r in results:
print(r.masks) # imprima o objeto Masks que contém as máscaras de instância detectadasVeja uma tabela com os métodos e as propriedades da classe Masks, incluindo nome, tipo e descrição:
| Nome | Tipo | Descrição |
|---|---|---|
data | Propriedade (torch.Tensor) | Tensor de máscara binária torch.uint8 com formato (N,H,W) e valores 0 ou 1. |
cpu() | Método | Retorna o tensor de máscaras na memória da CPU. |
numpy() | Método | Retorna o tensor de máscaras como um array NumPy. |
cuda() | Método | Retorna o tensor de máscaras na memória da GPU. |
to() | Método | Retorna o tensor de máscaras com o dispositivo e o tipo de dados especificados. |
xyn | Propriedade (list[np.ndarray]) | Uma lista de polígonos de máscara normalizados. |
xy | Propriedade (list[np.ndarray]) | Uma lista de polígonos de máscara em coordenadas de pixel. |
Para mais detalhes, consulta a documentação da classe Masks.
SemanticMask#
SemanticMask armazena um mapa de classes denso para resultados de segmentação semântica. Ao contrário de Masks, não contém uma máscara binária por objeto nem oferece funções auxiliares para polígonos.
from ultralytics import YOLO
# Carregue um modelo YOLO26n-sem Semantic pré-treinado
model = YOLO("yolo26n-sem.pt")
# Executa a inferência numa imagem
results = model("https://ultralytics.com/images/bus.jpg") # lista de resultados
# Ver resultados
for r in results:
print(r.semantic_mask.data) # imprima o mapa de IDs de classe H x W| Nome | Tipo | Descrição |
|---|---|---|
data | Propriedade (torch.Tensor) | Mapa de IDs de classe com formato (H,W). O tipo de dados é torch.uint8, torch.int16 ou torch.int32, selecionado de acordo com a quantidade de classes. |
shape | Propriedade (tuple) | Formato do mapa de classes, geralmente igual ao de result.orig_shape. |
cpu() | Método | Retorna o tensor da máscara semântica na memória da CPU. |
numpy() | Método | Retorna o tensor da máscara semântica como um array NumPy. |
cuda() | Método | Retorna o tensor da máscara semântica na memória da GPU. |
to() | Método | Retorna o tensor da máscara semântica com o dispositivo e o tipo de dados especificados. |
Pontos-chave#
O objeto Keypoints pode ser usado para indexar, manipular e normalizar coordenadas.
from ultralytics import YOLO
# Carregue um modelo YOLO26n-pose Pose pré-treinado
model = YOLO("yolo26n-pose.pt")
# Executa a inferência numa imagem
results = model("https://ultralytics.com/images/bus.jpg") # lista de resultados
# Ver resultados
for r in results:
print(r.keypoints) # imprima o objeto Keypoints que contém os pontos-chave detectadosVeja uma tabela com os métodos e as propriedades da classe Keypoints, incluindo nome, tipo e descrição:
| Nome | Tipo | Descrição |
|---|---|---|
cpu() | Método | Retorna o tensor de pontos-chave na memória da CPU. |
numpy() | Método | Retorna o tensor de pontos-chave como um array NumPy. |
cuda() | Método | Retorna o tensor de pontos-chave na memória da GPU. |
to() | Método | Retorna o tensor de pontos-chave com o dispositivo e o tipo de dados especificados. |
xyn | Propriedade (torch.Tensor) | Coordenadas normalizadas dos pontos-chave com formato (N,K,2). |
xy | Propriedade (torch.Tensor) | Coordenadas dos pontos-chave em pixels com formato (N,K,2). |
conf | Propriedade (torch.Tensor) | Retorna os valores de confiança dos pontos-chave, se disponíveis; caso contrário, retorna None. |
Para mais detalhes, consulta a documentação da classe Keypoints.
Probabilidades#
O objeto Probs pode ser usado para obter os índices e as pontuações de classificação top1 e top5.
from ultralytics import YOLO
# Carregue um modelo YOLO26n-cls Classify pré-treinado
model = YOLO("yolo26n-cls.pt")
# Executa a inferência numa imagem
results = model("https://ultralytics.com/images/bus.jpg") # lista de resultados
# Ver resultados
for r in results:
print(r.probs) # imprima o objeto Probs que contém as probabilidades das classes detectadasVeja uma tabela que resume os métodos e as propriedades da classe Probs:
| Nome | Tipo | Descrição |
|---|---|---|
cpu() | Método | Retorna uma cópia do tensor probs na memória da CPU. |
numpy() | Método | Retorna uma cópia do tensor probs como um array NumPy. |
cuda() | Método | Retorna uma cópia do tensor probs na memória da GPU. |
to() | Método | Retorna uma cópia do tensor probs com o dispositivo e o tipo de dados especificados. |
top1 | Propriedade (int) | Índice da classe com a maior pontuação. |
top5 | Propriedade (list[int]) | Índices das 5 classes com as maiores pontuações. |
top1conf | Propriedade (torch.Tensor) | Confiança da classe com a maior pontuação. |
top5conf | Propriedade (torch.Tensor) | Confianças das 5 classes com as maiores pontuações. |
Para mais detalhes, consulta a documentação da classe Probs.
OBB#
O objeto OBB pode ser usado para indexar, manipular e converter caixas delimitadoras orientadas para diferentes formatos.
from ultralytics import YOLO
# Carrega um modelo YOLO26n pré-treinado
model = YOLO("yolo26n-obb.pt")
# Executa a inferência numa imagem
results = model("https://ultralytics.com/images/boats.jpg") # lista de resultados
# Ver resultados
for r in results:
print(r.obb) # imprime o objeto OBB que contém as caixas delimitadoras das detecções orientadasVeja uma tabela com os métodos e as propriedades da classe OBB, incluindo nome, tipo e descrição:
| Nome | Tipo | Descrição |
|---|---|---|
cpu() | Método | Move o objeto para a memória da CPU. |
numpy() | Método | Converte o objeto em um array NumPy. |
cuda() | Método | Move o objeto para a memória CUDA. |
to() | Método | Move o objeto para o dispositivo especificado. |
conf | Propriedade (torch.Tensor) | Retorna os valores de confiança das caixas. |
cls | Propriedade (torch.Tensor) | Retorna os valores de classe das caixas. |
id | Propriedade (torch.Tensor) | Retorna os IDs de rastreamento das caixas (se disponíveis). |
xyxy | Propriedade (torch.Tensor) | Retorna as caixas horizontais no formato xyxy. |
xywhr | Propriedade (torch.Tensor) | Retorna as caixas rotacionadas no formato xywhr. |
xyxyxyxy | Propriedade (torch.Tensor) | Retorna as caixas rotacionadas no formato xyxyxyxy. |
xyxyxyxyn | Propriedade (torch.Tensor) | Retorna as caixas rotacionadas no formato xyxyxyxy normalizadas pelo tamanho da imagem. |
Para mais detalhes, consulta a documentação da classe OBB.
Visualização dos resultados#
O método plot() dos objetos Results facilita a visualização das predições ao sobrepor os objetos detectados (como caixas delimitadoras, máscaras, pontos-chave e probabilidades) à imagem original. Esse método retorna a imagem anotada como um array NumPy, facilitando sua exibição ou gravação.
from PIL import Image
from ultralytics import YOLO
# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")
# Run inference on 'bus.jpg'
results = model(["https://ultralytics.com/images/bus.jpg", "https://ultralytics.com/images/zidane.jpg"]) # results list
# Visualize the results
for i, r in enumerate(results):
# Plot results image
im_bgr = r.plot() # BGR-order numpy array
im_rgb = Image.fromarray(im_bgr[..., ::-1]) # RGB-order PIL image
# Show results to screen (in supported environments)
r.show()
# Save results to disk
r.save(filename=f"results{i}.jpg")Parâmetros do método plot()#
O método plot() aceita vários argumentos para personalizar a saída:
| Argumento | Tipo | Descrição | Padrão |
|---|---|---|---|
conf | bool | Inclui as pontuações de confiança das detecções. | True |
line_width | float | Espessura da linha das caixas delimitadoras. Ajusta-se ao tamanho da imagem se None. | None |
font_size | float | Tamanho da fonte do texto. Ajusta-se ao tamanho da imagem se None. | None |
font | str | Nome da fonte para as anotações de texto. | 'Arial.ttf' |
pil | bool | Retorna a imagem como um objeto PIL Image. | False |
img | np.ndarray | torch.Tensor | Imagem alternativa. Os tensores devem ser contíguos no formato HWC BGR uint8. | None |
kpt_radius | int | Raio dos pontos-chave desenhados. | 5 |
kpt_line | bool | Conecta os pontos-chave com linhas. | True |
labels | bool | Inclui os rótulos das classes nas anotações. | True |
boxes | bool | Sobrepõe as caixas delimitadoras à imagem. | True |
masks | bool | Sobrepõe as máscaras à imagem. | True |
probs | bool | Inclui as probabilidades de classificação. | True |
show | bool | Exibe a imagem anotada diretamente usando o visualizador de imagens padrão. | False |
save | bool | Salva a imagem anotada no arquivo especificado por filename. | False |
filename | str | Caminho e nome do arquivo em que a imagem anotada será salva se save for True. | None |
color_mode | str | Especifica o modo de cor, por exemplo, 'instance' ou 'class'. | 'class' |
txt_color | tuple[int, int, int] | Cor do texto em BGR para os rótulos de classificação. | (255, 255, 255) |
Inferência segura para threads#
Garantir a segurança dos threads durante a inferência é essencial ao executar vários modelos YOLO em paralelo, em threads diferentes. A inferência segura para threads garante que as previsões de cada thread sejam isoladas e não interfiram umas nas outras, evitando condições de corrida e assegurando resultados consistentes e confiáveis.
Ao usar modelos YOLO em um aplicativo multithread, é importante instanciar objetos de modelo separados para cada thread ou usar armazenamento local à thread para evitar conflitos:
Instancie um único modelo em cada thread para realizar inferências com segurança entre threads:
from threading import Thread
from ultralytics import YOLO
def thread_safe_predict(model, image_path):
"""Performs thread-safe prediction on an image using a locally instantiated YOLO model."""
model = YOLO(model)
results = model.predict(image_path)
# Processa os resultados
# Inicia threads, cada uma com sua própria instância do modelo
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image2.jpg")).start()Loop for da fonte de streaming#
Este é um script Python que usa OpenCV (cv2) e YOLO para executar inferências em quadros de vídeo. O script pressupõe que você já instalou os pacotes necessários (opencv-python e ultralytics).
import cv2
from ultralytics import YOLO
# Carregar o modelo YOLO
model = YOLO("yolo26n.pt")
# Abre o arquivo de vídeo
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)
# Percorre os quadros do vídeo
while cap.isOpened():
# Lê um quadro do vídeo
success, frame = cap.read()
if success:
# Executa a inferência YOLO no quadro
results = model(frame)
# Visualiza os resultados no quadro
annotated_frame = results[0].plot()
# Exibe o quadro anotado
cv2.imshow("YOLO Inference", annotated_frame)
# Interrompe o loop se 'q' for pressionado
if cv2.waitKey(1) & 0xFF == ord("q"):
break
else:
# Interrompe o loop se o vídeo chegar ao fim
break
# Libera o objeto de captura de vídeo e fecha a janela de exibição
cap.release()
cv2.destroyAllWindows()Este script executa predições em cada quadro do vídeo, visualiza os resultados e os exibe em uma janela. Você pode sair do loop pressionando 'q'.
O que fazer a seguir#
Pronto para ir além de um modelo pré-treinado? Confirme se a sua tarefa atende ao seu problema, formate seus próprios dados com o guia de conjuntos de dados e, em seguida, treine com eles.
Perguntas frequentes#
O Ultralytics YOLO é uma família de modelos de última geração para deteção de objetos, segmentação de instâncias, segmentação semântica, estimativa de profundidade, classificação, estimativa de pose e deteção de caixas delimitadoras orientadas (OBB) em tempo real. O modo de previsão executa inferência de alta velocidade em fontes de dados como imagens, vídeos e transmissões em direto, com suporte para processamento em lote e transmissão.
O Ultralytics YOLO pode processar uma ampla variedade de fontes de dados, incluindo imagens individuais, vídeos, diretórios, URLs e transmissões. Você pode especificar a fonte de dados na chamada
model.predict(). Por exemplo, use'image.jpg'para uma imagem local ou'https://ultralytics.com/images/bus.jpg'para uma URL. Confira os exemplos detalhados de várias fontes de inferência na documentação.Para otimizar a velocidade de inferência e gerenciar a memória com eficiência, você pode usar o modo de streaming definindo
stream=Trueno método de chamada do preditor. O modo de streaming gera um gerador de objetosResultscom uso eficiente de memória, em vez de carregar todos os quadros na memória. O modo de streaming é especialmente útil para processar vídeos longos ou grandes conjuntos de dados. Saiba mais sobre o modo de streaming.O método
model.predict()do YOLO aceita vários argumentos, comoconf,iou,imgsz,devicee outros. Esses argumentos permitem personalizar o processo de inferência, definindo parâmetros como limites de confiança, tamanho da imagem e dispositivo usado para a computação. Você encontra descrições detalhadas desses argumentos na seção argumentos de inferência.Use
model.embed(source)para extrair embeddings de características da penúltima camada ou passeembed=[layer_index]paramodel.predict()para escolher camadas específicas.from ultralytics import YOLO model = YOLO("yolo26n.pt") source = "https://ultralytics.com/images/bus.jpg" results = model.predict(source) # Objetos Results embeddings = model.embed(source) # lista de embeddings torch.TensorDepois de executar inferências com YOLO, os objetos
Resultscontêm métodos para exibir e salvar imagens anotadas. Você pode usar métodos comoresult.show()eresult.save(filename="result.jpg")para visualizar e salvar os resultados. Todos os diretórios-pai inexistentes no caminho do arquivo são criados automaticamente (por exemplo,result.save("path/to/result.jpg")). Para ver a lista completa desses métodos, consulte a seção trabalhar com resultados.
Comentários629
Faz uma pergunta, partilha os teus resultados ou ajuda alguém.
Tigores
你好,我想问一下为什么我在推理相同的图像时,设置不同的imgsz参数,会有不同的结果。在一张图像上,有大船、小船、人。imgsz设置的值有640(默认)、1280、1980。640只能检测到大船;1280会检测到大船和小船,并且大船的置信度更高;1980还能检测到人。我很疑惑,模型的输入尺寸不是在训练的时候就已经固定了吗,这是否意味着推理的图像预处理阶段,不管我如何调整imgsz参数,模型都会将输入图像采样到640。但是现在出现的不同的结果,是为什么呢?下面是我的代码: from ultralytics import YOLO model = YOLO("/data/dxh/ultralytics/weight/yolov8s.pt")
results = model("/data/dxh/ultralytics/datasets/test/invade_ship_cls/invade_result", imgsz=1280, save=True)1
Glenn JocherUltralytics@Tigores 您好!YOLO模型在推理时会自动将输入图像缩放到您指定的imgsz参数值(而非固定为训练尺寸),更大的分辨率能保留更多细节从而提升小目标检测能力。具体原理可参考Predict模式文档中的图像尺寸与精度关系说明,这是预期行为而非异常现象。
LwpZoe
Hello, I would like to ask, my task is instance segmentation. At present, I get the predicted result is the original image superimposed label image, but the result I want is just the RGB label image, no need to superimpose the original image. Where do I need to make changes to make the result a segmented label image?
1
Glenn JocherUltralytics(editado)@LwpZoe to obtain only the RGB label image without the original image overlay, you can disable the overlay during visualization. Use the
plot()method withboxes=Falseandmasks=Trueto only display the segmentation masks. Alternatively, you can directly accessresult.masks.datafor raw mask data and process it as needed. Refer to the Results section for more details.LwpZoe
Found plot () in yolo-segment-main/ultralytics/engine/results.py, modified content: Def plot ( Self, Conf = True, line_width = None, font_size = None, Font = "Arial.ttf", Pil = False, Img = None, im_gpu = None, kpt_radius = 5, kpt_line = False, Labels = False, Boxes = False, Masks = True, Probs = True, Show = True, Save = True, Filename = 'result', color_mode = "class", ): Make predictions using the command line: Yolo segment predict model = runs/segment/train/weights/best.pt source=yolo-seg-main/datasets/test The result is still the original image overlay mask and box, why? Does changing plot () require retraining to get best.pt in order to predict?
Glenn JocherUltralyticsTo display only the segmentation mask without overlays, modify the
plot()function parameters by settingboxes=False,labels=False, and ensuringmasks=True. You don't need retraining to adjust visualization settings, as the weights remain unaffected. For further details, refer to the Results.plot() documentation.
UserHello, when I run the predict script, I predict a large amount of image data (about more than 20,000 test images). At this time, the model's predict will get stuck, and I don't generate the image of the prediction box. How can I solve this bug?
1
Paula DerrengerUltralytics@Stephen-Hao it sounds like you might be running into memory issues when processing a large number of images. To handle large datasets more efficiently, consider using the
stream=Trueargument in yourmodel.predict()call. This will create a memory-efficient generator of results, reducing the likelihood of your system getting stuck. Additionally, ensure you are using the latest version of the Ultralytics package to benefit from any recent optimizations and bug fixes. If the issue persists, please provide more details about your environment and any error messages you encounter.
UserYes, Thank you a lot.
Paula DerrengerUltralytics@Stephen-Hao you're welcome! If you're experiencing issues with the model getting stuck while predicting a large number of images, try using the
stream=Trueargument in yourmodel.predict()call. This will help manage memory more efficiently by processing images one at a time instead of loading all at once. Also, ensure you're using the latest version of the Ultralytics package. If the problem persists, please provide more details about your setup and any error messages you encounter.
Johanna-Jones
Hey, Is there a way to get the MAP precision, IOU and other metrics for the test images you might give the model?
I have images and the ground truth for the test images but not sure how to get the same metrics for the PREDICT mode
Thank you!
1Johanna-Jones
For clarification my pipeline is currently train> valid with
valparameter set to false. I then pass one image at a time to the Yolov8 model in the PREDICT mode
Paula DerrengerUltralyticsHey there!
For evaluating your model with metrics like mAP, precision, and IOU on your test images, you should use the
Valmode rather than thePredictmode. TheValmode allows you to validate your model on a dataset and provides comprehensive metrics, including the ones you're interested in. Here's an example on how to do it:from ultralytics import YOLO # Assuming 'coco128.yaml' is your dataset configuration file that includes your test data path # and that 'your_model.pt' is the trained model you want to evaluate model = YOLO('path/to/your_model.pt') # Validate the model, this will automatically calculate mAP, IOU, and other metrics results = model.val(data='path/to/your_dataset_config.yaml')Remember to adjust
'path/to/your_model.pt'and'path/to/your_dataset_config.yaml'to the actual paths of your model and dataset configuration file.In your YAML dataset configuration file, make sure to correctly specify the path to your test images and annotations. This way, YOLOv8 will know how to find your test data and corresponding ground truth for evaluation.
If you have any more questions, feel free to ask. Good luck with your model evaluation! 🚀
GUPABE10
how to ignore printing results after inference: 0: 384x640 10 persons, 1 sports ball, 4080.4ms Speed: 12.3ms preprocess, 4080.4ms inference, 1.7ms postprocess per image at shape (1, 3, 384, 640)
1
Glenn JocherUltralyticsTo disable printing inference results after running predictions, you can use the
verbose=Falseargument in yourpredict()function. This will prevent the printout of inference times and detected objects. Here's a quick example on how to do it:from ultralytics import YOLO # Load your YOLOv8 model model = YOLO('yolov8n.pt') # Run inference with verbose=False results = model.predict('path/to/your/image.jpg', verbose=False)This should keep your console output clean while still performing inference. 😊
GUPABE10
Is it the same if I use:
results = model('path/to/your/image.jpg')
just as mentioned in the example in this tutorial.
Glenn JocherUltralytics@GUPABE10 hi there!
Yes, using
results = model('path/to/your/image.jpg')is perfectly fine and aligns with the examples provided in the tutorial. This command will run inference on the specified image and return the results as a list ofResultsobjects.If you want to avoid printing the detailed inference results (like the number of detected objects and processing times), you can use the
verbose=Falseargument:from ultralytics import YOLO # Load a pretrained YOLOv8n model model = YOLO("yolov8n.pt") # Run inference on an image without printing detailed results results = model.predict('path/to/your/image.jpg', verbose=False)This will keep your console output clean while still performing the inference. If you have any more questions or need further assistance, feel free to ask! 😊
GUPABE10
What is the difference between model.predict() and model()?
Glenn JocherUltralyticsHi there!
Great question! The difference between
model.predict()andmodel()lies in their usage and flexibility:-
model.predict():- This method is explicitly designed for running predictions and allows you to pass various arguments to customize the inference process.
- You can specify parameters like
save,imgsz,conf,device, and more to control the behavior of the prediction. - Example:
from ultralytics import YOLO # Load a pretrained YOLOv8n model model = YOLO("yolov8n.pt") # Run inference with custom arguments results = model.predict("path/to/image.jpg", save=True, imgsz=320, conf=0.5)
-
model():- This is a shorthand method that calls the
predict()function internally with default settings. - It is useful for quick predictions without needing to specify additional parameters.
- Example:
from ultralytics import YOLO # Load a pretrained YOLOv8n model model = YOLO("yolov8n.pt") # Run inference with default settings results = model("path/to/image.jpg")
- This is a shorthand method that calls the
Both methods will return a list of
Resultsobjects, which you can then process as needed. If you need more control over the prediction process,model.predict()is the way to go. For quick and straightforward predictions,model()is convenient.Feel free to check out the Ultralytics documentation on prediction for more details and examples.
Happy coding! 😊
-
amani784
Hello @glenn-jocher, i have question, my inputs are videos, if i use vid-stride , can i use imgsz with it ?
Glenn JocherUltralyticsYes—
vid_stride(frame skipping) andimgsz(inference resize) are independent, so you can use them together on video sources;imgszwill be applied to the frames that are actually processed (see the Predict mode inference arguments).yolo predict model=yolo26n.pt source=video.mp4 vid_stride=2 imgsz=640from ultralytics import YOLO model = YOLO("yolo26n.pt") for r in model.predict("video.mp4", vid_stride=2, imgsz=640, stream=True): pass1amani784
Thank you for your help. I have another question: if I don’t define imgsz in predict, will it resize the image to 640 by default? I have multiple inputs with different resolutions, so I can’t specify a single value for imgsz in .predict or even during ONNX export, because sometimes the input resolution is larger than imgsz.
Glenn JocherUltralyticsYes—if you don’t pass
imgsztopredict(), it uses the defaultimgsz=640and will letterbox/resize each frame/image to that inference size (so larger inputs are downscaled, smaller are upscaled); for mixed-resolution sources you can either leave the default or set a largerimgszfor more detail (GPU memory permitting) as described in the predict settings defaults.If you need an ONNX that can accept varying input shapes at runtime, export with dynamic shapes enabled (then your runtime can feed different H×W sizes):
yolo export model=yolo26n.pt format=onnx dynamic=Truefrom ultralytics import YOLO model = YOLO("yolo26n.pt") model.export(format="onnx", dynamic=True)Feel free to drop the exact input resolutions (and whether this is video-only) here in the discussion and we can suggest a good
imgszstrategy for your case.1amani784
Thank you so much ,but for tensorRT export , the model can't accept varying input shapes and i was obliged to put imgsz or my videos have different resolutions and i can't put one imgsz value that can fit all the resolutions. Is there any other solution?
Glenn JocherUltralyticsYes—TensorRT doesn’t have to be fixed-shape: export your
.enginewithdynamic=Trueso the runtime can accept varying input shapes (you can then chooseimgszper run/video), see the Export mode docs and the TensorRT integration guide.yolo export model=yolo26n.pt format=engine dynamic=TrueIf you need peak throughput and your resolutions vary a lot, the usual workaround is exporting 2–3 fixed engines at common
imgszvalues and selecting the closest one at runtime.1
Asshok1
Hey @glenn-jocher, I’m trying to integrate a TensorRT-optimized YOLO model (.engine) with SAHI (Slicing Aided Hyper Inference) for efficient large-image inference, but I’m facing difficulties making them work together correctly as .engine is not accepted in sahi, can you help in providing the complete code for integrating tensorRT with sahi.
Glenn JocherUltralyticsSAHI’s built-in Ultralytics integration (
model_type="ultralytics") currently expects PyTorch weights like*.pt, so a TensorRT*.enginefile won’t load through SAHI as-is; the supported path is to use SAHI with*.ptper the SAHI tiled inference guide, or run the TensorRT engine directly with Ultralytics per the TensorRT export/inference guide. If you specifically need SAHI slicing + a*.engine, you’ll need a custom SAHIDetectionModeladapter around Ultralytics’ TensorRT predictor (best tracked upstream in the SAHI repository); please paste your Ultralytics/SAHI versions and a minimal repro here in the discussion so we can advise on the cleanest adapter approach.# SAHI (supported): Ultralytics *.pt + slicing from sahi import AutoDetectionModel from sahi.predict import get_sliced_prediction detection_model = AutoDetectionModel.from_pretrained( model_type="ultralytics", model_path="best.pt", confidence_threshold=0.25, device="cuda:0", ) result = get_sliced_prediction( "large.jpg", detection_model, slice_height=640, slice_width=640, overlap_height_ratio=0.2, overlap_width_ratio=0.2, )# TensorRT (supported): Ultralytics *.engine inference (no SAHI wrapper) from ultralytics import YOLO model = YOLO("best.engine") results = model.predict("large.jpg", device=0, imgsz=640)
hanchaoyuan
hello! I used the YOLO11-pose model to estimate the key points of people in the automotive production workshop. However, the model often identified vehicles, hoists and other equipment as humans and calculated the key points, resulting in a relatively high false alarm rate. My question is: How can we prevent the model from identifying other objects and reduce the false alarm rate?
Glenn JocherUltralyticsFor workshop false positives with pose models, the quickest lever is raising the prediction threshold (and optionally increasing
imgszfor better person discrimination), but the most reliable fix is fine-tuning on your own workshop data with “hard negative” images (frames with vehicles/hoists but no people) so the model learns your background; see the inference args in the predict mode docs.yolo pose predict model=yolo11n-pose.pt source=path/to/video.mp4 conf=0.6 imgsz=960If you paste your exact command, plus a couple representative frames (people + false positives) here in the discussion, we can suggest tighter settings or a training setup (and for new work, try a YOLO26 pose checkpoint as it’s generally stronger out of the box).
d5423197
Hi there,
If no boxes/masks detected by the model, what will be the output of model inference. (results = model(["image1.jpg", "image2.jpg"]) #)
I want to deal with the edge case.
max-dev-14
How to predict and show or save prediction YOLO (custom model) for video fragment?
