Ultralytics YOLO27:
Get Started

Conteggio degli oggetti con Ultralytics YOLO26#

Cos'è il conteggio degli oggetti?#

Open Object Counting In Colab

Il conteggio degli oggetti con Ultralytics YOLO26 consiste nell'identificare e contare con precisione oggetti specifici nei video e nei flussi delle telecamere. YOLO26 eccelle nelle applicazioni in tempo reale, offrendo un conteggio degli oggetti efficiente e preciso in diversi scenari, come l'analisi della folla e la videosorveglianza, grazie ad algoritmi all'avanguardia e alle capacità di deep learning.



Guarda: Come eseguire il conteggio degli oggetti in tempo reale con Ultralytics YOLO26 🚀

Vantaggi del conteggio degli oggetti#

  • Ottimizzazione delle risorse: Il conteggio degli oggetti favorisce una gestione efficiente delle risorse fornendo conteggi accurati e ottimizzando l'allocazione delle risorse in applicazioni come la gestione dell'inventario.
  • Maggiore sicurezza: Il conteggio degli oggetti migliora la sicurezza e la videosorveglianza tracciando e contando con precisione le entità, contribuendo al rilevamento proattivo delle minacce.
  • Decisioni consapevoli: Il conteggio degli oggetti offre informazioni preziose per prendere decisioni e ottimizzare i processi nel commercio al dettaglio, nella gestione del traffico e in molti altri ambiti.

Applicazioni nel mondo reale#

LogisticaAcquacoltura
Conteggio dei pacchi sul nastro trasportatore con Ultralytics YOLO26Conteggio dei pesci in mare con Ultralytics YOLO26
Conteggio dei pacchi sul nastro trasportatore con Ultralytics YOLO26Conteggio dei pesci in mare con Ultralytics YOLO26

Conta gli oggetti con YOLO26#

Definisci una region di conteggio — due punti per una linea oppure tre o più per un poligono — e passala alla soluzione ObjectCounter. Il contatore traccia ogni oggetto tra i fotogrammi e aggiorna i conteggi IN/OUT quando gli oggetti tracciati attraversano la linea o passano nella regione, restituendo un fotogramma annotato che puoi scrivere in un video di output.

Conteggio degli oggetti con Ultralytics YOLO
# Run a counting example
yolo solutions count show=True

# Pass a source video
yolo solutions count source="path/to/video.mp4"

# Pass region coordinates
yolo solutions count region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]"

L'argomento region accetta due punti (per una linea) oppure un poligono con tre o più punti. Definisci le coordinate nell'ordine in cui devono essere collegate, così il contatore saprà esattamente dove avvengono gli ingressi e le uscite.

Argomenti di ObjectCounter#

Ecco una tabella con gli argomenti di ObjectCounter:

ArgomentoTipoPredefinitoDescrizione
modelstrNonePercorso a un file modello Ultralytics YOLO.
show_inboolTrueFlag che controlla se visualizzare i conteggi in entrata nello stream video.
show_outboolTrueFlag che controlla se visualizzare i conteggi in uscita nello stream video.
regionlist o dictNonePunti che definiscono la regione di interesse: un elenco di tuple (x, y) oppure un dizionario che associa i nomi delle regioni agli elenchi di punti per più regioni (solo RegionCounter). Quando None, le soluzioni che richiedono una regione usano un valore predefinito predefinito.
line_widthint2Spessore delle linee dei riquadri, dei punti chiave e dei conteggi disegnati dalla soluzione.
verboseboolTrueAbilita il log per frame della soluzione, con forma dell'input, conteggi per classe e velocità di elaborazione. La chiamata di tracking è sempre silenziosa.

La soluzione ObjectCounter consente di usare diversi argomenti track:

ArgomentoTipoPredefinitoDescrizione
trackerstr'tracktrack.yaml'Specifica l'algoritmo di tracciamento da usare. Opzioni integrate: botsort.yaml, bytetrack.yaml, ocsort.yaml, deepocsort.yaml, fasttrack.yaml, tracktrack.yaml.
conffloat0.25Imposta la soglia di confidenza per le rilevazioni; valori più bassi consentono di tracciare più oggetti, ma possono includere falsi positivi.
ioufloat0.7Imposta la soglia di Intersezione sull'unione (IoU) per filtrare le rilevazioni sovrapposte.
classeslistNoneFiltra i risultati in base all'indice della classe. Ad esempio, classes=[0, 2, 3] traccia solo le classi specificate.
devicestrNoneSpecifica il dispositivo per l'inferenza (ad es. cpu, cuda:0 o 0). Consente di scegliere tra CPU, una GPU specifica o altri dispositivi di calcolo per l'esecuzione del modello.
imgszint or tuple640Dimensione dell'immagine di destinazione per l'inferenza: un intero per un'immagine quadrata o una coppia (height, width). Le forme vengono adattate allo stride del modello.
max_detint300Numero massimo di rilevazioni da mantenere per fotogramma prima del tracciamento, che limita gli oggetti elaborati da una soluzione nelle scene dense.
quantizeint or strNonePrecisione dell'inferenza: 16 (FP16) oppure 32/non impostata (FP32) per i modelli PyTorch e TorchScript; gli altri formati eseguono i calcoli con la precisione scelta dall'artefatto e dal runtime. Sostituisce il flag deprecato half.

Sono supportati anche gli argomenti di visualizzazione elencati di seguito:

ArgomentoTipoPredefinitoDescrizione
showboolFalseSe True, mostra le immagini o i video annotati in una finestra. Utile per ottenere un riscontro visivo immediato durante lo sviluppo o i test.
show_confboolTrueMostra il punteggio di confidenza di ogni rilevamento accanto all'etichetta. Fornisce indicazioni sul grado di certezza del modello per ciascun rilevamento.
show_labelsboolTrueMostra le etichette di ogni rilevamento nell'output visivo. Permette di identificare immediatamente gli oggetti rilevati.

Domande frequenti#

  • Per contare gli oggetti in un video con Ultralytics YOLO26, puoi seguire questi passaggi:

    1. Importa le librerie necessarie (cv2, ultralytics).
    2. Definisci la regione di conteggio (ad es. un poligono, una linea e così via).
    3. Configura l'acquisizione video e inizializza il contatore degli oggetti.
    4. Elabora ogni fotogramma per tracciare gli oggetti e contarli all'interno della regione definita.

    Ecco un semplice esempio di conteggio in una regione:

    import cv2
    
    from ultralytics import solutions
    
    def count_objects_in_region(video_path, output_video_path, model_path):
        """Count objects in a specific region within a video."""
        cap = cv2.VideoCapture(video_path)
        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))
        video_writer = cv2.VideoWriter(output_video_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
    
        region_points = [(20, 400), (1080, 400), (1080, 360), (20, 360)]
        counter = solutions.ObjectCounter(show=True, region=region_points, model=model_path)
    
        while cap.isOpened():
            success, im0 = cap.read()
            if not success:
                print("Video frame is empty or processing is complete.")
                break
            results = counter(im0)
            video_writer.write(results.plot_im)
    
        cap.release()
        video_writer.release()
        cv2.destroyAllWindows()
    
    count_objects_in_region("path/to/video.mp4", "output_video.avi", "yolo26n.pt")

    Per configurazioni e opzioni più avanzate, consulta la soluzione RegionCounter per contare simultaneamente gli oggetti in più regioni.

  • Usare Ultralytics YOLO26 per il conteggio degli oggetti offre diversi vantaggi:

    1. Ottimizzazione delle risorse: Offre una gestione efficiente delle risorse fornendo conteggi accurati e aiutando a ottimizzare l'allocazione delle risorse in settori come la gestione dell'inventario.
    2. Maggiore sicurezza: Migliora la sicurezza e la videosorveglianza tracciando e contando con precisione le entità, contribuendo al rilevamento proattivo delle minacce e ai sistemi di sicurezza.
    3. Decisioni consapevoli: Offre informazioni preziose per prendere decisioni e ottimizzare i processi in ambiti come il commercio al dettaglio, la gestione del traffico e altri ancora.
    4. Elaborazione in tempo reale: L'architettura di YOLO26 consente l'inferenza in tempo reale, rendendolo adatto ai flussi video dal vivo e alle applicazioni sensibili ai tempi.

    Per esempi di implementazione e applicazioni pratiche, esplora la soluzione TrackZone per tracciare gli oggetti in zone specifiche.

  • Per contare classi specifiche di oggetti con Ultralytics YOLO26, devi specificare le classi che ti interessano durante la fase di tracciamento. Ecco un esempio in Python:

    import cv2
    
    from ultralytics import solutions
    
    def count_specific_classes(video_path, output_video_path, model_path, classes_to_count):
        """Count specific classes of objects in a video."""
        cap = cv2.VideoCapture(video_path)
        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))
        video_writer = cv2.VideoWriter(output_video_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
    
        line_points = [(20, 400), (1080, 400)]
        counter = solutions.ObjectCounter(show=True, region=line_points, model=model_path, classes=classes_to_count)
    
        while cap.isOpened():
            success, im0 = cap.read()
            if not success:
                print("Video frame is empty or processing is complete.")
                break
            results = counter(im0)
            video_writer.write(results.plot_im)
    
        cap.release()
        video_writer.release()
        cv2.destroyAllWindows()
    
    count_specific_classes("path/to/video.mp4", "output_specific_classes.avi", "yolo26n.pt", [0, 2])

    In questo esempio, classes_to_count=[0, 2] indica che vengono contati gli oggetti delle classi 0 e 2 (ad es. persone e auto nel dataset COCO). Puoi trovare altre informazioni sugli indici delle classi nella documentazione del dataset COCO.

  • Ultralytics YOLO26 offre diversi vantaggi rispetto ad altri modelli di rilevamento degli oggetti, come Faster R-CNN, SSD e le versioni precedenti di YOLO:

    1. Velocità ed efficienza: YOLO26 consente l'elaborazione in tempo reale, risultando ideale per le applicazioni che richiedono inferenza ad alta velocità, come la videosorveglianza e la guida autonoma.
    2. Precisione: Offre una precisione di rilevamento e tracciamento all'avanguardia, riducendo i falsi positivi e migliorando l'affidabilità complessiva del sistema.
    3. Facilità di integrazione: YOLO26 si integra facilmente con diverse piattaforme e dispositivi, inclusi quelli mobili e i dispositivi edge, una caratteristica essenziale per le moderne applicazioni di AI.
    4. Flessibilità: Supporta le attività di rilevamento e segmentazione, con la modalità di tracciamento e modelli configurabili per soddisfare requisiti specifici dei casi d'uso.

    Consulta la documentazione di YOLO26 di Ultralytics per approfondire le funzionalità e confrontare le prestazioni.

  • Sì, Ultralytics YOLO26 è particolarmente adatto ad applicazioni avanzate come l'analisi della folla e la gestione del traffico grazie alle sue capacità di rilevamento in tempo reale, alla scalabilità e alla flessibilità di integrazione. Le sue funzionalità avanzate consentono di tracciare, contare e classificare gli oggetti con grande precisione in ambienti dinamici. Ecco alcuni esempi di casi d'uso:

    • Analisi della folla: Monitora e gestisci grandi assembramenti, garantendo la sicurezza e ottimizzando il flusso delle persone con il conteggio basato sulle regioni.
    • Gestione del traffico: Traccia e conta i veicoli, analizza i flussi di traffico e gestisci la congestione in tempo reale grazie alla stima della velocità.
    • Analisi per il commercio al dettaglio: Analizza gli spostamenti dei clienti e le interazioni con i prodotti per ottimizzare la disposizione dei negozi e migliorare l'esperienza dei clienti.
    • Automazione industriale: Conta i prodotti sui nastri trasportatori e monitora le linee di produzione per il controllo della qualità e il miglioramento dell'efficienza.

    Per applicazioni più specifiche, esplora Ultralytics Solutions, una raccolta completa di strumenti per affrontare le sfide reali della visione artificiale.

Commenti