Analítica utilizando Ultralytics YOLOv8

Introdução

Este guia fornece uma visão geral abrangente de três tipos fundamentais de visualizações de dados: gráficos de linhas, gráficos de barras e gráficos de pizza. Cada secção inclui instruções passo a passo e snippets de código sobre como criar estas visualizações utilizando Python.

Amostras visuais

Gráfico de linhas	Traçado de barras	Gráfico de pizza

Porque é que os gráficos são importantes

Os gráficos de linhas são ideais para acompanhar as alterações durante períodos curtos e longos e para comparar as alterações de vários grupos durante o mesmo período.
Os gráficos de barras, por outro lado, são adequados para comparar quantidades em diferentes categorias e mostrar relações entre uma categoria e o seu valor numérico.
Por último, os gráficos de pizza são eficazes para ilustrar proporções entre categorias e mostrar partes de um todo.

Exemplos de análise

Gráfico de linhasLinhas múltiplasGráfico de pizzaTraçado de barrasGráfico de áreas

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")

cap = cv2.VideoCapture("Path/to/video/file.mp4")
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

out = cv2.VideoWriter("line_plot.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(
    type="line",
    writer=out,
    im0_shape=(w, h),
    view_img=True,
)
total_counts = 0
frame_count = 0

while cap.isOpened():
    success, frame = cap.read()

    if success:
        frame_count += 1
        results = model.track(frame, persist=True, verbose=True)

        if results[0].boxes.id is not None:
            boxes = results[0].boxes.xyxy.cpu()
            for box in boxes:
                total_counts += 1

        analytics.update_line(frame_count, total_counts)

        total_counts = 0
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break

cap.release()
out.release()
cv2.destroyAllWindows()

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")

cap = cv2.VideoCapture("Path/to/video/file.mp4")
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
out = cv2.VideoWriter("multiple_line_plot.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(
    type="line",
    writer=out,
    im0_shape=(w, h),
    view_img=True,
    max_points=200,
)

frame_count = 0
data = {}
labels = []

while cap.isOpened():
    success, frame = cap.read()

    if success:
        frame_count += 1

        results = model.track(frame, persist=True)

        if results[0].boxes.id is not None:
            boxes = results[0].boxes.xyxy.cpu()
            track_ids = results[0].boxes.id.int().cpu().tolist()
            clss = results[0].boxes.cls.cpu().tolist()

            for box, track_id, cls in zip(boxes, track_ids, clss):
                # Store each class label
                if model.names[int(cls)] not in labels:
                    labels.append(model.names[int(cls)])

                # Store each class count
                if model.names[int(cls)] in data:
                    data[model.names[int(cls)]] += 1
                else:
                    data[model.names[int(cls)]] = 0

        # update lines every frame
        analytics.update_multiple_lines(data, labels, frame_count)
        data = {}  # clear the data list for next frame
    else:
        break

cap.release()
out.release()
cv2.destroyAllWindows()

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")

cap = cv2.VideoCapture("Path/to/video/file.mp4")
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

out = cv2.VideoWriter("pie_chart.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(
    type="pie",
    writer=out,
    im0_shape=(w, h),
    view_img=True,
)

clswise_count = {}

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True, verbose=True)
        if results[0].boxes.id is not None:
            boxes = results[0].boxes.xyxy.cpu()
            clss = results[0].boxes.cls.cpu().tolist()
            for box, cls in zip(boxes, clss):
                if model.names[int(cls)] in clswise_count:
                    clswise_count[model.names[int(cls)]] += 1
                else:
                    clswise_count[model.names[int(cls)]] = 1

            analytics.update_pie(clswise_count)
            clswise_count = {}

        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break

cap.release()
out.release()
cv2.destroyAllWindows()

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")

cap = cv2.VideoCapture("Path/to/video/file.mp4")
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

out = cv2.VideoWriter("bar_plot.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(
    type="bar",
    writer=out,
    im0_shape=(w, h),
    view_img=True,
)

clswise_count = {}

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True, verbose=True)
        if results[0].boxes.id is not None:
            boxes = results[0].boxes.xyxy.cpu()
            clss = results[0].boxes.cls.cpu().tolist()
            for box, cls in zip(boxes, clss):
                if model.names[int(cls)] in clswise_count:
                    clswise_count[model.names[int(cls)]] += 1
                else:
                    clswise_count[model.names[int(cls)]] = 1

            analytics.update_bar(clswise_count)
            clswise_count = {}

        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break

cap.release()
out.release()
cv2.destroyAllWindows()

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")

cap = cv2.VideoCapture("path/to/video/file.mp4")
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

out = cv2.VideoWriter("area_plot.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(
    type="area",
    writer=out,
    im0_shape=(w, h),
    view_img=True,
)

clswise_count = {}
frame_count = 0

while cap.isOpened():
    success, frame = cap.read()
    if success:
        frame_count += 1
        results = model.track(frame, persist=True, verbose=True)

        if results[0].boxes.id is not None:
            boxes = results[0].boxes.xyxy.cpu()
            clss = results[0].boxes.cls.cpu().tolist()

            for box, cls in zip(boxes, clss):
                if model.names[int(cls)] in clswise_count:
                    clswise_count[model.names[int(cls)]] += 1
                else:
                    clswise_count[model.names[int(cls)]] = 1

        analytics.update_area(frame_count, clswise_count)
        clswise_count = {}
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break

cap.release()
out.release()
cv2.destroyAllWindows()

Argumenta `Analytics`

Aqui tens uma tabela com os Analytics argumentos:

Nome	Tipo	Predefinição	Descrição
`type`	`str`	`None`	Tipo de dados ou objeto.
`im0_shape`	`tuple`	`None`	Forma da imagem inicial.
`writer`	`cv2.VideoWriter`	`None`	Objeto para escrever ficheiros de vídeo.
`title`	`str`	`ultralytics`	Título para a visualização.
`x_label`	`str`	`x`	Rotula o eixo x.
`y_label`	`str`	`y`	Rotula o eixo y.
`bg_color`	`str`	`white`	Cor de fundo.
`fg_color`	`str`	`black`	Cor do primeiro plano.
`line_color`	`str`	`yellow`	Cor das linhas.
`line_width`	`int`	`2`	Largura das linhas.
`fontsize`	`int`	`13`	Tamanho da letra para o texto.
`view_img`	`bool`	`False`	Marca para apresentar a imagem ou o vídeo.
`save_img`	`bool`	`True`	Marca para guardar a imagem ou o vídeo.
`max_points`	`int`	`50`	Para linhas múltiplas, total de pontos desenhados no quadro, antes de excluir os pontos iniciais.
`points_width`	`int`	`15`	Marcador de pontos de largura da linha.

Argumentos `model.track`

Argumenta	Tipo	Predefinição	Descrição
`source`	`str`	`None`	Specifies the source directory for images or videos. Supports file paths and URLs.
`persist`	`bool`	`False`	Enables persistent tracking of objects between frames, maintaining IDs across video sequences.
`tracker`	`str`	`botsort.yaml`	Specifies the tracking algorithm to use, e.g., `bytetrack.yaml` ou `botsort.yaml`.
`conf`	`float`	`0.3`	Sets the confidence threshold for detections; lower values allow more objects to be tracked but may include false positives.
`iou`	`float`	`0.5`	Sets the Intersection over Union (IoU) threshold for filtering overlapping detections.
`classes`	`list`	`None`	Filters results by class index. For example, `classes=[0, 2, 3]` only tracks the specified classes.
`verbose`	`bool`	`True`	Controls the display of tracking results, providing a visual output of tracked objects.

Conclusão

Compreender quando e como utilizar diferentes tipos de visualizações é crucial para uma análise de dados eficaz. Os gráficos de linhas, os gráficos de barras e os gráficos de pizza são ferramentas fundamentais que podem ajudar-te a transmitir a história dos teus dados de forma mais clara e eficaz.

FAQ

Como posso criar um gráfico de linhas utilizando Ultralytics YOLOv8 Analytics?

Para criar um gráfico de linhas utilizando Ultralytics YOLOv8 Analytics, segue estes passos:

Carrega um modelo YOLOv8 e abre o teu ficheiro de vídeo.
Inicializa o Analytics com o tipo definido como "linha".
Itera através dos quadros de vídeo, atualizando o gráfico de linhas com dados relevantes, como a contagem de objetos por quadro.
Guarda o vídeo de saída que apresenta o gráfico de linhas.

Exemplo:

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")
cap = cv2.VideoCapture("Path/to/video/file.mp4")
out = cv2.VideoWriter("line_plot.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(type="line", writer=out, im0_shape=(w, h), view_img=True)

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True)
        total_counts = sum([1 for box in results[0].boxes.xyxy])
        analytics.update_line(frame_count, total_counts)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
out.release()
cv2.destroyAllWindows()

Para mais pormenores sobre a configuração do Analytics visita o site Analítica utilizando Ultralytics YOLOv8 📊 secção.

Quais são as vantagens de utilizar Ultralytics YOLOv8 para criar gráficos de barras?

A utilização de Ultralytics YOLOv8 para criar gráficos de barras oferece várias vantagens:

Visualização de dados em tempo real: Integra perfeitamente os resultados da deteção de objectos em gráficos de barras para actualizações dinâmicas.
Facilidade de utilização: A API e as funções simples facilitam a implementação e a visualização de dados.
Personalização: Personaliza títulos, etiquetas, cores e muito mais para satisfazer os teus requisitos específicos.
Eficiência: Lida eficientemente com grandes quantidades de dados e actualiza os gráficos em tempo real durante o processamento de vídeo.

Utiliza o seguinte exemplo para gerar um gráfico de barras:

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")
cap = cv2.VideoCapture("Path/to/video/file.mp4")
out = cv2.VideoWriter("bar_plot.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(type="bar", writer=out, im0_shape=(w, h), view_img=True)

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True)
        clswise_count = {
            model.names[int(cls)]: boxes.size(0)
            for cls, boxes in zip(results[0].boxes.cls.tolist(), results[0].boxes.xyxy)
        }
        analytics.update_bar(clswise_count)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
out.release()
cv2.destroyAllWindows()

Para saberes mais, visita a secção Traçado de barras no guia.

Por que razão devo utilizar Ultralytics YOLOv8 para criar gráficos de pizza nos meus projectos de visualização de dados?

Ultralytics YOLOv8 é uma excelente escolha para criar gráficos de pizza porque:

Integração com a deteção de objectos: Integra diretamente os resultados da deteção de objectos em gráficos de pizza para obter informações imediatas.
API de fácil utilização: Simples de configurar e utilizar com um código mínimo.
Personalizável: Várias opções de personalização para cores, etiquetas e muito mais.
Actualizações em tempo real: Trata e visualiza os dados em tempo real, o que é ideal para projectos de análise de vídeo.

Eis um exemplo rápido:

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")
cap = cv2.VideoCapture("Path/to/video/file.mp4")
out = cv2.VideoWriter("pie_chart.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(type="pie", writer=out, im0_shape=(w, h), view_img=True)

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True)
        clswise_count = {
            model.names[int(cls)]: boxes.size(0)
            for cls, boxes in zip(results[0].boxes.cls.tolist(), results[0].boxes.xyxy)
        }
        analytics.update_pie(clswise_count)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
out.release()
cv2.destroyAllWindows()

Para mais informações, consulta a secção Gráfico de tartes do guia.

O Ultralytics YOLOv8 pode ser utilizado para seguir objectos e atualizar dinamicamente as visualizações?

Sim, Ultralytics YOLOv8 pode ser utilizado para seguir objectos e atualizar dinamicamente as visualizações. Suporta o seguimento de vários objectos em tempo real e pode atualizar várias visualizações, como gráficos de linhas, gráficos de barras e gráficos de pizza, com base nos dados dos objectos seguidos.

Exemplo de seguimento e atualização de um gráfico de linhas:

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")
cap = cv2.VideoCapture("Path/to/video/file.mp4")
out = cv2.VideoWriter("line_plot.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(type="line", writer=out, im0_shape=(w, h), view_img=True)

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True)
        total_counts = sum([1 for box in results[0].boxes.xyxy])
        analytics.update_line(frame_count, total_counts)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
out.release()
cv2.destroyAllWindows()

Para obteres informações sobre a funcionalidade completa, consulta a secção Seguimento.

O que torna o Ultralytics YOLOv8 diferente de outras soluções de deteção de objectos como o OpenCV e o TensorFlow?

Ultralytics YOLOv8 destaca-se de outras soluções de deteção de objectos como o OpenCV e o TensorFlow por várias razões:

Precisão de última geração: YOLOv8 proporciona uma precisão superior em tarefas de deteção, segmentação e classificação de objectos.
Facilidade de utilização: A API de fácil utilização permite uma rápida implementação e integração sem necessidade de codificação extensiva.
Desempenho em tempo real: Optimizado para inferência a alta velocidade, adequado para aplicações em tempo real.
Diversas aplicações: Suporta várias tarefas, incluindo rastreamento de vários objetos, treinamento de modelos personalizados e exportação para diferentes formatos, como ONNX, TensorRT e CoreML.
Documentação abrangente: Documentação extensa e recursos de blogue para orientar os utilizadores em cada passo.

Para comparações mais detalhadas e casos de utilização, explora o nosso blogueUltralytics .

📅 Created 3 months ago ✏️ Updated 3 days ago