Analítica mediante Ultralytics YOLOv8

Q: What makes Ultralytics YOLOv8 different from other object detection solutions like OpenCV and TensorFlow?

Ultralytics YOLOv8 destaca sobre otras soluciones de detección de objetos como OpenCV y TensorFlow por múltiples razones: Para obtener comparaciones y casos de uso más detallados, explora nuestro Blog Ultralytics .

Introducción

Esta guía proporciona una visión completa de tres tipos fundamentales de visualizaciones de datos: gráficos de líneas, diagramas de barras y gráficos circulares. Cada sección incluye instrucciones paso a paso y fragmentos de código sobre cómo crear estas visualizaciones utilizando Python.

Muestras visuales

Gráfico lineal	Trama de barras	Gráfico circular

Por qué son importantes los gráficos

Los gráficos de líneas son ideales para seguir los cambios durante periodos cortos y largos y para comparar los cambios de varios grupos durante el mismo periodo.
Los diagramas de barras, en cambio, son adecuados para comparar cantidades entre distintas categorías y mostrar las relaciones entre una categoría y su valor numérico.
Por último, los gráficos circulares son eficaces para ilustrar proporciones entre categorías y mostrar partes de un todo.

Ejemplos de análisis

Gráfico linealLíneas múltiplesGráfico circularTrama 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()

Argumento `Analytics`

Aquí tienes una tabla con los Analytics argumentos:

Nombre	Tipo	Por defecto	Descripción
`type`	`str`	`None`	Tipo de dato u objeto.
`im0_shape`	`tuple`	`None`	Forma de la imagen inicial.
`writer`	`cv2.VideoWriter`	`None`	Objeto para escribir archivos de vídeo.
`title`	`str`	`ultralytics`	Título para la visualización.
`x_label`	`str`	`x`	Etiqueta para el eje x.
`y_label`	`str`	`y`	Etiqueta para el eje y.
`bg_color`	`str`	`white`	Color de fondo.
`fg_color`	`str`	`black`	Color de primer plano.
`line_color`	`str`	`yellow`	Color de las líneas.
`line_width`	`int`	`2`	Anchura de las líneas.
`fontsize`	`int`	`13`	Tamaño de letra del texto.
`view_img`	`bool`	`False`	Bandera para mostrar la imagen o el vídeo.
`save_img`	`bool`	`True`	Marca para guardar la imagen o el vídeo.
`max_points`	`int`	`50`	En el caso de varias líneas, el total de puntos dibujados en el marco, antes de eliminar los puntos iniciales.
`points_width`	`int`	`15`	Ancho del resaltador de puntos de línea.

Argumentos `model.track`

Nombre	Tipo	Por defecto	Descripción
`source`	`im0`	`None`	directorio fuente de imágenes o vídeos
`persist`	`bool`	`False`	persistencia de pistas entre fotogramas
`tracker`	`str`	`botsort.yaml`	Método de seguimiento 'bytetrack' o 'botsort'
`conf`	`float`	`0.3`	Umbral de confianza
`iou`	`float`	`0.5`	Umbral del pagaré
`classes`	`list`	`None`	filtrar los resultados por clase, es decir, classes=0, o classes=[0,2,3]
`verbose`	`bool`	`True`	Mostrar los resultados del seguimiento de objetos

Conclusión

Comprender cuándo y cómo utilizar distintos tipos de visualizaciones es crucial para un análisis eficaz de los datos. Los gráficos de líneas, los diagramas de barras y los gráficos circulares son herramientas fundamentales que pueden ayudarte a transmitir la historia de tus datos de forma más clara y eficaz.

PREGUNTAS FRECUENTES

¿Cómo creo un gráfico de líneas utilizando Ultralytics YOLOv8 Analytics?

Para crear un gráfico de líneas utilizando Ultralytics YOLOv8 Analytics, sigue estos pasos:

Carga un modelo YOLOv8 y abre tu archivo de vídeo.
Inicializa el Analytics con el tipo definido como "línea".
Iterar a través de los fotogramas de vídeo, actualizando el gráfico de líneas con los datos relevantes, como el recuento de objetos por fotograma.
Guarda el vídeo de salida que muestra el gráfico lineal.

Ejemplo:

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 más detalles sobre la configuración del Analytics clase, visita la página Analítica utilizando Ultralytics YOLOv8 📊 sección.

¿Qué ventajas tiene utilizar Ultralytics YOLOv8 para crear gráficos de barras?

Utilizar Ultralytics YOLOv8 para crear gráficos de barras ofrece varias ventajas:

Visualización de datos en tiempo real: Integra perfectamente los resultados de la detección de objetos en gráficos de barras para una actualización dinámica.
Facilidad de uso: la API y las funciones sencillas facilitan la implementación y visualización de los datos.
Personalización: Personaliza títulos, etiquetas, colores y mucho más para adaptarlos a tus requisitos específicos.
Eficacia: Maneja eficazmente grandes cantidades de datos y actualiza los gráficos en tiempo real durante el procesamiento del vídeo.

Utiliza el siguiente ejemplo para generar un 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 saber más, visita la sección Trama de barras de la guía.

¿Por qué debería utilizar Ultralytics YOLOv8 para crear gráficos circulares en mis proyectos de visualización de datos?

Ultralytics YOLOv8 es una opción excelente para crear gráficos circulares porque

Integración con la Detección de Objetos: Integra directamente los resultados de la detección de objetos en gráficos circulares para obtener información inmediata.
API fácil de usar: Fácil de configurar y utilizar con un código mínimo.
Personalizable: Varias opciones de personalización para colores, etiquetas y mucho más.
Actualizaciones en tiempo real: Maneja y visualiza los datos en tiempo real, lo que es ideal para proyectos de análisis de vídeo.

He aquí un ejemplo 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 más información, consulta la sección Gráfico circular de la guía.

¿Puede utilizarse Ultralytics YOLOv8 para rastrear objetos y actualizar dinámicamente las visualizaciones?

Sí, Ultralytics YOLOv8 puede utilizarse para rastrear objetos y actualizar visualizaciones dinámicamente. Admite el seguimiento de múltiples objetos en tiempo real y puede actualizar diversas visualizaciones, como gráficos de líneas, diagramas de barras y gráficos circulares, basándose en los datos de los objetos rastreados.

Ejemplo de seguimiento y actualización de un gráfico lineal:

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 conocer la funcionalidad completa, consulta la sección Seguimiento.

¿Qué diferencia a Ultralytics YOLOv8 de otras soluciones de detección de objetos como OpenCV y TensorFlow?

Ultralytics YOLOv8 se distingue de otras soluciones de detección de objetos como OpenCV y TensorFlow por múltiples razones:

Precisión de vanguardia: YOLOv8 proporciona una precisión superior en tareas de detección, segmentación y clasificación de objetos.
Facilidad de uso: La API fácil de usar permite una implementación e integración rápidas sin necesidad de una codificación exhaustiva.
Rendimiento en tiempo real: Optimizado para la inferencia a alta velocidad, adecuado para aplicaciones en tiempo real.
Aplicaciones diversas: Admite diversas tareas, como el seguimiento de múltiples objetos, el entrenamiento de modelos personalizados y la exportación a diferentes formatos como ONNX, TensorRT y CoreML.
Documentación exhaustiva: Amplia documentación y recursos de blog para guiar a los usuarios en cada paso.

Para obtener comparaciones y casos de uso más detallados, explora nuestro BlogUltralytics .

Creado 2024-05-23, Actualizado 2024-07-05
Autores: glenn-jocher (4), IvorZhu331 (1), RizwanMunawar (3)