Analitica con l'utilizzo di Ultralytics YOLOv8

Introduzione

Questa guida fornisce una panoramica completa di tre tipi fondamentali di visualizzazioni di dati: grafici a linee, grafici a barre e grafici a torta. Ogni sezione include istruzioni passo-passo e snippet di codice su come creare queste visualizzazioni utilizzando Python.

Campioni visivi

Grafico a linee	Trama della barra	Grafico a torta

Perché i grafici sono importanti

I grafici a linee sono ideali per monitorare i cambiamenti su periodi brevi e lunghi e per confrontare i cambiamenti di più gruppi nello stesso periodo.
I grafici a barre, invece, sono adatti a confrontare le quantità tra diverse categorie e a mostrare le relazioni tra una categoria e il suo valore numerico.
Infine, i grafici a torta sono efficaci per illustrare le proporzioni tra le categorie e mostrare le parti di un insieme.

Esempi di analisi

Grafico a lineeLinee multipleGrafico a tortaTrama della barraGrafico dell'area

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

Argomento `Analytics`

Ecco una tabella con i dati Analytics argomenti:

Nome	Tipo	Predefinito	Descrizione
`type`	`str`	`None`	Tipo di dati o di oggetto.
`im0_shape`	`tuple`	`None`	Forma dell'immagine iniziale.
`writer`	`cv2.VideoWriter`	`None`	Oggetto per la scrittura di file video.
`title`	`str`	`ultralytics`	Titolo della visualizzazione.
`x_label`	`str`	`x`	Etichetta per l'asse x.
`y_label`	`str`	`y`	Etichetta per l'asse y.
`bg_color`	`str`	`white`	Colore di sfondo.
`fg_color`	`str`	`black`	Colore di primo piano.
`line_color`	`str`	`yellow`	Colore delle linee.
`line_width`	`int`	`2`	Larghezza delle linee.
`fontsize`	`int`	`13`	Dimensione del carattere per il testo.
`view_img`	`bool`	`False`	Bandiera per visualizzare l'immagine o il video.
`save_img`	`bool`	`True`	Contrassegno per salvare l'immagine o il video.
`max_points`	`int`	`50`	Per più linee, punti totali disegnati sulla cornice, prima di eliminare i punti iniziali.
`points_width`	`int`	`15`	Evidenziatore della larghezza dei punti della linea.

Argomenti `model.track`

Argomento	Tipo	Predefinito	Descrizione
`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` o `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.

Conclusione

Capire quando e come utilizzare i diversi tipi di visualizzazione è fondamentale per un'analisi efficace dei dati. I grafici a linee, a barre e a torta sono strumenti fondamentali che possono aiutarti a trasmettere la storia dei tuoi dati in modo più chiaro ed efficace.

DOMANDE FREQUENTI

Come posso creare un grafico a linee utilizzando Ultralytics YOLOv8 Analytics?

Per creare un grafico a linee utilizzando Ultralytics YOLOv8 Analytics, segui i seguenti passaggi:

Carica un modello YOLOv8 e apri il tuo file video.
Inizializza l'opzione Analytics con il tipo impostato su "linea".
Itera i fotogrammi del video, aggiornando il grafico a linee con i dati rilevanti, come il numero di oggetti per fotogramma.
Salva il video di uscita che visualizza il grafico a linee.

Esempio:

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

Per ulteriori dettagli sulla configurazione di Analytics visita il sito Analytics con Ultralytics YOLOv8 📊 sezione.

Quali sono i vantaggi dell'utilizzo di Ultralytics YOLOv8 per la creazione di grafici a barre?

L'utilizzo di Ultralytics YOLOv8 per la creazione di grafici a barre offre diversi vantaggi:

Visualizzazione dei dati in tempo reale: Integra senza problemi i risultati del rilevamento degli oggetti in grafici a barre per aggiornamenti dinamici.
Facilità d'uso: API e funzioni semplici rendono immediata l'implementazione e la visualizzazione dei dati.
Personalizzazione: Personalizza titoli, etichette, colori e altro ancora per adattarli alle tue esigenze specifiche.
Efficienza: Gestisci in modo efficiente grandi quantità di dati e aggiorna i grafici in tempo reale durante l'elaborazione dei video.

Usa il seguente esempio per generare un grafico a barre:

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

Per saperne di più, visita la sezione Trama delle barre della guida.

Perché dovrei utilizzare Ultralytics YOLOv8 per creare grafici a torta nei miei progetti di visualizzazione dei dati?

Ultralytics YOLOv8 è una scelta eccellente per creare grafici a torta perché:

Integrazione con il rilevamento degli oggetti: Integra direttamente i risultati del rilevamento degli oggetti nei grafici a torta per ottenere informazioni immediate.
API di facile utilizzo: Semplice da configurare e utilizzare con un codice minimo.
Personalizzabile: Varie opzioni di personalizzazione per colori, etichette e altro ancora.
Aggiornamenti in tempo reale: Gestisci e visualizza i dati in tempo reale, l'ideale per i progetti di analisi video.

Ecco un rapido esempio:

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

Per maggiori informazioni, consulta la sezione Grafico a torta della guida.

Ultralytics YOLOv8 può essere utilizzato per tracciare gli oggetti e aggiornare dinamicamente le visualizzazioni?

Sì, Ultralytics YOLOv8 può essere utilizzato per tracciare gli oggetti e aggiornare dinamicamente le visualizzazioni. Supporta il tracciamento di più oggetti in tempo reale e può aggiornare diverse visualizzazioni come grafici a linee, a barre e a torta in base ai dati degli oggetti tracciati.

Esempio di tracciamento e aggiornamento di un grafico a linee:

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

Per conoscere tutte le funzionalità, consulta la sezione Tracciamento.

Cosa rende Ultralytics YOLOv8 diverso da altre soluzioni di rilevamento degli oggetti come OpenCV e TensorFlow?

Ultralytics YOLOv8 si distingue da altre soluzioni di rilevamento degli oggetti come OpenCV e TensorFlow per diversi motivi:

Precisione all'avanguardia: YOLOv8 offre una precisione superiore nel rilevamento, nella segmentazione e nella classificazione degli oggetti.
Facilità d'uso: L'API di facile utilizzo consente un'implementazione e un'integrazione rapida senza dover ricorrere a una codifica approfondita.
Prestazioni in tempo reale: Ottimizzato per l'inferenza ad alta velocità, adatto alle applicazioni in tempo reale.
Diverse applicazioni: Supporta diverse attività, tra cui il tracciamento di più oggetti, la formazione di modelli personalizzati e l'esportazione in diversi formati come ONNX, TensorRT e CoreML.
Documentazione completa: Un'ampia documentazione e risorse blog per guidare gli utenti in ogni fase.

Per confronti e casi d'uso più dettagliati, esplora il nostro blogUltralytics .

📅 Created 3 months ago ✏️ Updated 5 days ago