Salta para o conteúdo

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
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

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

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.

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:

  1. Carrega um modelo YOLOv8 e abre o teu ficheiro de vídeo.
  2. Inicializa o Analytics com o tipo definido como "linha".
  3. Itera através dos quadros de vídeo, atualizando o gráfico de linhas com dados relevantes, como a contagem de objetos por quadro.
  4. 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:

  1. 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.
  2. Facilidade de utilização: A API e as funções simples facilitam a implementação e a visualização de dados.
  3. Personalização: Personaliza títulos, etiquetas, cores e muito mais para satisfazer os teus requisitos específicos.
  4. 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:

  1. 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.
  2. API de fácil utilização: Simples de configurar e utilizar com um código mínimo.
  3. Personalizável: Várias opções de personalização para cores, etiquetas e muito mais.
  4. 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:

  1. Precisão de última geração: YOLOv8 proporciona uma precisão superior em tarefas de deteção, segmentação e classificação de objectos.
  2. 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.
  3. Desempenho em tempo real: Optimizado para inferência a alta velocidade, adequado para aplicações em tempo real.
  4. 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.
  5. 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 .



Criado em 2024-05-23, Atualizado em 2024-07-05
Autores: glenn-jocher (4), IvorZhu331 (1), RizwanMunawar (3)

Comentários