Analytik mit Ultralytics YOLOv8 📊

Einführung

Dieser Leitfaden bietet einen umfassenden Überblick über drei grundlegende Arten von Datenvisualisierungen: Liniendiagramme, Balkendiagramme und Kreisdiagramme. Jeder Abschnitt enthält Schritt-für-Schritt-Anleitungen und Codeschnipsel, wie du diese Visualisierungen mit Python erstellen kannst.

Visuelle Muster

Liniendiagramm	Bar Plot	Tortendiagramm

Warum Diagramme wichtig sind

Liniendiagramme sind ideal, um Veränderungen über kurze und lange Zeiträume zu verfolgen und um Veränderungen für mehrere Gruppen über denselben Zeitraum zu vergleichen.
Balkendiagramme hingegen eignen sich für den Vergleich von Mengen über verschiedene Kategorien hinweg und zeigen Beziehungen zwischen einer Kategorie und ihrem Zahlenwert.
Schließlich sind Kreisdiagramme gut geeignet, um die Proportionen zwischen den Kategorien zu veranschaulichen und Teile eines Ganzen darzustellen.

Analytik Beispiele

LiniendiagrammMultiple LinesTortendiagrammBar PlotArea 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()

Argument `Analytics`

Hier ist eine Tabelle mit den Analytics Argumente:

Name	Typ	Standard	Beschreibung
`type`	`str`	`None`	Art der Daten oder des Objekts.
`im0_shape`	`tuple`	`None`	Die Form des Ausgangsbildes.
`writer`	`cv2.VideoWriter`	`None`	Objekt zum Schreiben von Videodateien.
`title`	`str`	`ultralytics`	Titel für die Visualisierung.
`x_label`	`str`	`x`	Beschriftung für die x-Achse.
`y_label`	`str`	`y`	Beschriftung für die y-Achse.
`bg_color`	`str`	`white`	Hintergrundfarbe.
`fg_color`	`str`	`black`	Vordergrundfarbe.
`line_color`	`str`	`yellow`	Farbe der Linien.
`line_width`	`int`	`2`	Breite der Linien.
`fontsize`	`int`	`13`	Schriftgröße für Text.
`view_img`	`bool`	`False`	Flagge, um das Bild oder Video anzuzeigen.
`save_img`	`bool`	`True`	Flagge, um das Bild oder Video zu speichern.
`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.

Argumente `model.track`

Name	Typ	Standard	Beschreibung
`source`	`im0`	`None`	Quellverzeichnis für Bilder oder Videos
`persist`	`bool`	`False`	Spuren zwischen Frames beibehalten
`tracker`	`str`	`botsort.yaml`	Tracking-Methode 'bytetrack' oder 'botsort'
`conf`	`float`	`0.3`	Konfidenzschwelle
`iou`	`float`	`0.5`	IOU-Schwelle
`classes`	`list`	`None`	Ergebnisse nach Klassen filtern, d.h. classes=0, oder classes=[0,2,3]
`verbose`	`bool`	`True`	Anzeige der Ergebnisse der Objektverfolgung

Fazit

Für eine effektive Datenanalyse ist es wichtig zu wissen, wann und wie du die verschiedenen Arten von Visualisierungen einsetzen solltest. Liniendiagramme, Balkendiagramme und Tortendiagramme sind grundlegende Werkzeuge, die dir helfen können, die Geschichte deiner Daten klarer und effektiver zu vermitteln.

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