Predição de modelos com Ultralytics YOLO#

Introdução#

No mundo da aprendizagem automática e da visão computacional, o processo de interpretar dados visuais é frequentemente chamado de inferência ou predição. O Ultralytics YOLO26 oferece uma funcionalidade avançada conhecida como modo predict, concebida para inferência de alto desempenho e em tempo real numa ampla variedade de fontes de dados.

Consulta a pré-visualização não lançada do YOLO27 para ver exemplos de inferência planeados.

Aplicações no mundo real#

Porquê usar o Ultralytics YOLO para inferência?#

Eis por que deves considerar o modo predict do YOLO26 para as tuas várias necessidades de inferência:

• Versatilidade: Capaz de executar inferência em imagens, vídeos e até transmissões em direto.
• Desempenho: Desenvolvido para processamento em tempo real e de alta velocidade, sem sacrificar a precisão.
• Facilidade de utilização: Interfaces intuitivas de Python e CLI para implementação e testes rápidos.
• Altamente personalizável: Várias definições e parâmetros permitem ajustar o comportamento de inferência do modelo de acordo com os teus requisitos específicos.
• Pronto para produção: Implementa modelos como endpoints de inferência da Ultralytics Platform, com escalabilidade automática e monitorização, ou executa a inferência localmente.

Principais funcionalidades do modo predict#

O modo predict do YOLO26 foi concebido para ser robusto e versátil, incluindo:

• Compatibilidade com várias fontes de dados: Quer os teus dados estejam na forma de imagens individuais, uma coleção de imagens, ficheiros de vídeo ou transmissões de vídeo em tempo real, o modo predict trata de tudo.
• Modo de streaming: Usa a funcionalidade de streaming para gerar um gerador eficiente em termos de memória de objetos Results. Ativa-a definindo stream=True no método de chamada do preditor. Ao contrário do comportamento predefinido (stream=False), que devolve uma lista com todos os resultados, stream=True produz os resultados um de cada vez, sendo especialmente útil para vídeos longos e transmissões em direto.
• Processamento em lotes: Processa várias imagens ou frames de vídeo num único lote, reduzindo ainda mais o tempo total de inferência.
• Fácil integração: Integra facilmente com pipelines de dados existentes e outros componentes de software, graças à sua API flexível.

Os modelos Ultralytics YOLO devolvem uma lista Python de objetos Results ou um gerador eficiente em termos de memória de objetos Results quando stream=True é passado ao modelo durante a inferência:

from ultralytics import YOLO

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

# Run batched inference on a list of images
results = model(["image1.jpg", "image2.jpg"])  # return a list of Results objects

# Process results list
for result in results:
    boxes = result.boxes  # Boxes object for bounding box outputs
    masks = result.masks  # Masks object for segmentation masks outputs
    keypoints = result.keypoints  # Keypoints object for pose outputs
    probs = result.probs  # Probs object for classification outputs
    obb = result.obb  # Oriented boxes object for OBB outputs
    result.show()  # display to screen
    result.save(filename="result.jpg")  # save to disk

Fontes de inferência#

O YOLO26 pode processar diferentes tipos de fontes de entrada para inferência, conforme apresentado na 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 em direto, pois cria um gerador de resultados em vez de carregar todos os frames para a memória.

Abaixo encontram-se exemplos de código para utilizar cada tipo de fonte:

from ultralytics import YOLO

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

# Define path to the image file
source = "path/to/image.jpg"

# Run inference on the source
results = model(source)  # list of Results objects

Argumentos de inferência#

model.predict() aceita vários argumentos que podem ser passados no momento da inferência para substituir os valores predefinidos:

Forma fixa vs retângulo mínimo (rect)#

Por predefinição, predict usa rect=True, que ativa o preenchimento de retângulo mínimo quando possível. A imagem é redimensionada para caber em imgsz e preenchida apenas até ao múltiplo de stride mais próximo, pelo que o tensor final pode ser menor do que imgsz. O preenchimento de retângulo mínimo só é utilizado quando todas as imagens do lote têm a mesma forma e o backend o suporta (.pt do PyTorch ou ONNX / Triton dinâmico). Caso contrário, as imagens são preenchidas até ao destino completo imgsz.

Usa rect=False para preencher sempre até ao destino completo imgsz. Isto é recomendado quando precisas de um tamanho de entrada fixo para corresponder a modelos exportados (ONNX, TensorRT, etc.).

Inteiro vs tuplo imgsz

• Um inteiro imgsz=640 torna-se num destino quadrado (640, 640) após o arredondamento pelo stride.
• Um tuplo imgsz=(384, 672) define um destino retangular. Com rect=True e auto=True, o tensor real pode ser menor do que este destino.

Treino vs predict/export

O treino aceita apenas um único inteiro imgsz (uma lista [h, w] é convertida no maior valor). Predict e export aceitam um inteiro ou um tuplo (height, width).

from ultralytics import YOLO

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

# Run inference on 'bus.jpg' with arguments
model.predict("https://ultralytics.com/images/bus.jpg", save=True, imgsz=320, conf=0.25)

Argumentos de inferência:

Argumentos de visualização:

Formatos de imagem e vídeo#

YOLO26 suporta 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 de previsão.

Imagens#

A tabela abaixo contém formatos de imagem Ultralytics válidos.

Vídeos#

A tabela abaixo contém formatos de vídeo Ultralytics válidos.

Trabalhar com resultados#

Todas as chamadas Ultralytics predict() devolvem uma lista de objetos Results:

from ultralytics import YOLO

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

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")
results = model(
    [
        "https://ultralytics.com/images/bus.jpg",
        "https://ultralytics.com/images/zidane.jpg",
    ]
)  # batch inference

Os objetos Results têm os seguintes atributos:

Resultados por tarefa#

Quais campos abaixo são preenchidos depende da tarefa do teu modelo — compara deteção, segmentação, segmentação semântica, estimativa de profundidade, classificação, pose e OBB se ainda não escolheste uma. Cada predição devolve um objeto Results por imagem ou fotograma. Os campos comuns acima estão sempre disponíveis, enquanto os dados de predição específicos da tarefa são armazenados nos campos abaixo. Os tensores de coordenadas e confiança YOLO são torch.float32; os tensores de probabilidade são torch.float32, a menos que seja usada precisão misturada/metade, caso em que são torch.float16. Após result.numpy(), os tensores tornam-se matrizes do NumPy com tipos de dados (dtypes) do NumPy correspondentes. As máscaras de instância são tensores binários torch.uint8, enquanto as máscaras semânticas utilizam o tipo de dados inteiro mais prático para IDs de classe: torch.uint8, torch.int16 ou torch.int32, dependendo da contagem de classes.

Os objetos Results têm os seguintes métodos:

Para mais detalhes, consulta a documentação da classe Results.

Caixas#

O objeto Boxes pode ser utilizado para indexar, manipular e converter caixas delimitadoras para diferentes formatos.

from ultralytics import YOLO

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

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

# View results
for r in results:
    print(r.boxes)  # print the Boxes object containing the detection bounding boxes

Eis uma tabela com os métodos e propriedades da classe Boxes, incluindo o respetivo nome, tipo e descrição:

Para mais detalhes, consulta a documentação da classe Boxes.

Máscaras#

O objeto Masks pode ser utilizado para indexar, manipular e converter máscaras em segmentos.

from ultralytics import YOLO

# Load a pretrained YOLO26n-seg Segment model
model = YOLO("yolo26n-seg.pt")

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

# View results
for r in results:
    print(r.masks)  # print the Masks object containing the detected instance masks

Eis uma tabela com os métodos e propriedades da classe Masks, incluindo o respetivo nome, tipo e descrição:

Para mais detalhes, consulta a documentação da classe Masks.

SemanticMask#

SemanticMask armazena um mapa denso de classes para resultados de segmentação semântica. Ao contrário de Masks, não contém uma máscara binária por objeto e não fornece auxiliares para polígonos.

from ultralytics import YOLO

# Load a pretrained YOLO26n-sem Semantic model
model = YOLO("yolo26n-sem.pt")

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

# View results
for r in results:
    print(r.semantic_mask.data)  # print the H x W class-ID map

Pontos-chave#

O objeto Keypoints pode ser utilizado para indexar, manipular e normalizar coordenadas.

from ultralytics import YOLO

# Load a pretrained YOLO26n-pose Pose model
model = YOLO("yolo26n-pose.pt")

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

# View results
for r in results:
    print(r.keypoints)  # print the Keypoints object containing the detected keypoints

Eis uma tabela com os métodos e propriedades da classe Keypoints, incluindo o respetivo nome, tipo e descrição:

Para mais detalhes, consulta a documentação da classe Keypoints.

Probs#

O objeto Probs pode ser utilizado para obter os índices e as pontuações de classificação top1 e top5.

from ultralytics import YOLO

# Load a pretrained YOLO26n-cls Classify model
model = YOLO("yolo26n-cls.pt")

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

# View results
for r in results:
    print(r.probs)  # print the Probs object containing the detected class probabilities

Eis uma tabela que resume os métodos e as propriedades da classe Probs:

Para mais detalhes, consulta a documentação da classe Probs.

OBB#

O objeto OBB pode ser utilizado para indexar, manipular e converter caixas delimitadoras orientadas para diferentes formatos.

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n-obb.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/boats.jpg")  # results list

# View results
for r in results:
    print(r.obb)  # print the OBB object containing the oriented detection bounding boxes

Eis uma tabela com os métodos e propriedades da classe OBB, incluindo o respetivo nome, tipo e descrição:

Para mais detalhes, consulta a documentação da classe OBB.

Resultados da plotagem#

O método plot() nos objetos Results facilita a visualização das previsões ao sobrepor objetos detetados (como caixas delimitadoras, máscaras, pontos-chave e probabilidades) na imagem original. Este método devolve a imagem anotada como uma matriz NumPy, permitindo apresentá-la ou guardá-la facilmente.

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 o resultado:

Inferência segura para threads#

Garantir a segurança dos threads durante a inferência é essencial quando executas vários modelos YOLO em paralelo em diferentes threads. A inferência segura para threads garante que as previsões de cada thread ficam isoladas e não interferem umas com as outras, evitando condições de corrida e assegurando resultados consistentes e fiáveis.

Ao utilizar modelos YOLO numa aplicação multithread, é importante instanciar objetos de modelo separados para cada thread ou utilizar armazenamento local ao thread para evitar conflitos:

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)
    # Process results

# Starting threads that each have their own model instance
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image2.jpg")).start()

Para uma análise aprofundada da inferência segura para threads com modelos YOLO e instruções passo a passo, consulta o nosso Guia de inferência YOLO segura para threads. Este guia fornece todas as informações necessárias para evitar problemas comuns e garantir que a tua inferência multithread funciona sem problemas.

Ciclo for de origem em streaming#

Eis um script Python que utiliza OpenCV (cv2) e YOLO para executar inferência em frames de vídeo. Este script pressupõe que já instalaste os pacotes necessários (opencv-python e ultralytics).

import cv2

from ultralytics import YOLO

# Load the YOLO model
model = YOLO("yolo26n.pt")

# Open the video file
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLO inference on the frame
        results = model(frame)

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLO Inference", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

Este script executa previsões em cada frame do vídeo, visualiza os resultados e apresenta-os numa janela. Podes sair do ciclo premindo 'q'.

E agora?#

Pronto para avançar para além de um modelo pré-treinado? Confirma que a tua tarefa se adequa ao teu problema, formata os teus próprios dados com o guia de conjuntos de dados e, em seguida, treina o modelo com eles.

Perguntas frequentes#