YOLOv8: object detection AI in Python per sysadmin e sviluppatori

YOLOv8 è il modello di object detection più usato al mondo. Gira su CPU normale — su un i7 moderno fa 25-30 FPS su video 720p senza GPU. Installi un pacchetto, scrivi tre righe di Python, e sai riconoscere persone, veicoli, oggetti in un video in tempo reale. Niente cloud, niente costi variabili, niente dati che escono.

Installazione e primo test in 3 comandi

pip install ultralytics
yolo predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg'
yolo predict model=yolov8n.pt source=0  # webcam

Il primo comando installa tutto. Il secondo scarica il modello yolov8n (nano, 6MB) e lo esegue su un’immagine di test — vedi i bounding box su persone e bus. Il terzo lo esegue sulla webcam in tempo reale.

I modelli vanno da yolov8n (nano, veloce, meno preciso) a yolov8x (extra-large, più lento ma preciso al ~55% mAP su COCO). Per uso reale su CPU, yolov8n o yolov8s sono il punto di partenza giusto.

Connessione a camera IP ONVIF via RTSP

Se hai telecamere IP sulla rete (Hikvision, Dahua, qualsiasi camera ONVIF), si connettono via stream RTSP:

from ultralytics import YOLO

model = YOLO("yolov8n.pt")

for result in model.track(source="rtsp://admin:password@192.168.0.92/stream1",
                           stream=True, persist=True):
    # result.boxes contiene bounding box, confidence, class
    boxes = result.boxes
    for box in boxes:
        cls = result.names[int(box.cls)]
        conf = float(box.conf)
        print(f"{cls}: {conf:.2f}")

stream=True processa frame per frame senza caricare tutto in memoria. persist=True abilita il tracking tra frame — necessario per ByteTrack. L’URL RTSP varia per marca: per Hikvision di solito è rtsp://user:pass@IP/Streaming/Channels/101.

Tracking con ByteTrack: contare persone uniche

YOLOv8 da solo ti dice “in questo frame ci sono 3 persone”. ByteTrack ti dice “quella persona è la stessa del frame precedente, l’ID è 42”. Con il tracking puoi contare visite uniche, calcolare dwell time, rilevare intrusioni.

from ultralytics import YOLO
from collections import defaultdict

model = YOLO("yolov8n.pt")
track_history = defaultdict(list)
unique_ids = set()

for result in model.track(source="rtsp://192.168.0.92/stream1",
                           stream=True, persist=True, tracker="bytetrack.yaml"):
    if result.boxes.id is not None:
        for track_id, cls_idx in zip(result.boxes.id.int(), result.boxes.cls.int()):
            if result.names[int(cls_idx)] == "person":
                unique_ids.add(int(track_id))

print(f"Persone uniche rilevate: {len(unique_ids)}")

ByteTrack è incluso in ultralytics — non serve installare nulla. Per use case pratici: contare clienti in entrata a un negozio, monitorare accessi a una zona riservata, rilevare veicoli in un parcheggio.

Deploy su server con FastAPI davanti

Per esporre le rilevazioni come API REST:

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from ultralytics import YOLO
import cv2, base64

app = FastAPI()
model = YOLO("yolov8n.pt")

@app.get("/detect")
async def detect_stream():
    def generate():
        cap = cv2.VideoCapture("rtsp://192.168.0.92/stream1")
        while True:
            ret, frame = cap.read()
            if not ret:
                break
            results = model(frame)
            annotated = results[0].plot()
            _, buffer = cv2.imencode('.jpg', annotated)
            yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n'
                   + buffer.tobytes() + b'\r\n')
    return StreamingResponse(generate(), media_type="multipart/x-mixed-replace; boundary=frame")

docker-compose.yml minimo:

services:
  detector:
    build: .
    ports:
      - "8000:8000"
    volumes:
      - ./models:/app/models
    devices:
      - /dev/video0:/dev/video0  # solo se usi webcam USB

Cosa fare

• Installa ultralytics e testa yolov8n sulla webcam o su un video locale prima di toccare telecamere IP — devi vedere i box funzionare in locale per calibrare le aspettative.
• Per le telecamere ONVIF, verifica l’URL RTSP con VLC prima di usarlo nel codice: VLC → Apri rete → rtsp://user:pass@IP/stream1.
• Aggiungi ByteTrack solo se hai bisogno di identità persistente tra frame — se ti serve solo “quanti oggetti ci sono adesso”, la detection semplice è sufficiente e più veloce.