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 linhasMultiple LinesGráfico de pizzaTraçado de barrasArea chart

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`	For multiple lines, total points drawn on frame, before deleting initial points.
`points_width`	`int`	`15`	Width of line points highlighter.

Argumentos `model.track`

Nome	Tipo	Predefinição	Descrição
`source`	`im0`	`None`	diretório de origem para imagens ou vídeos
`persist`	`bool`	`False`	persistência de faixas entre fotogramas
`tracker`	`str`	`botsort.yaml`	Método de rastreio 'bytetrack' ou 'botsort'
`conf`	`float`	`0.3`	Limiar de confiança
`iou`	`float`	`0.5`	Limiar IOU
`classes`	`list`	`None`	filtra os resultados por classe, ou seja, classes=0, ou classes=[0,2,3]
`verbose`	`bool`	`True`	Apresenta os resultados do rastreio de objectos

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.

Created 2024-05-23, Updated 2024-06-10
Authors: glenn-jocher (3), IvorZhu331 (1), RizwanMunawar (3)