Inizia

Stima della velocità con Ultralytics YOLO26

Che cos’è la stima della velocità?#

La stima della velocità è il processo di calcolo della velocità di movimento di un oggetto in un determinato contesto, spesso usato nelle applicazioni di visione artificiale. Con Ultralytics YOLO26 puoi calcolare la velocità degli oggetti usando il tracciamento degli oggetti insieme ai dati relativi a distanza e tempo, una soluzione utile per attività come il monitoraggio del traffico e la sorveglianza.



Guarda: Stima della velocità con Ultralytics YOLO26

Vantaggi della stima della velocità#

  • Gestione efficiente del traffico: una stima accurata della velocità aiuta a gestire il flusso del traffico, aumenta la sicurezza e riduce la congestione stradale.
  • Navigazione autonoma precisa: nei sistemi autonomi come le auto a guida autonoma, una stima affidabile della velocità garantisce una navigazione sicura e precisa del veicolo.
  • Maggiore sicurezza nella videosorveglianza: la stima della velocità nell’analisi dei filmati di videosorveglianza aiuta a individuare comportamenti insoliti o potenziali minacce, migliorando l’efficacia delle misure di sicurezza.

Applicazioni nel mondo reale#

TrasportiTrasporti
Stima della velocità su strada con Ultralytics YOLO26Stima della velocità su un ponte con Ultralytics YOLO26
Stima della velocità su strada con Ultralytics YOLO26Stima della velocità su un ponte con Ultralytics YOLO26
La velocità è una stima

La velocità è una stima e potrebbe non essere del tutto precisa. I risultati variano anche in base alle specifiche della telecamera e ad altri fattori correlati.

Stima la velocità con YOLO26#

La soluzione SpeedEstimator traccia ogni oggetto tra i vari fotogrammi e converte il suo spostamento in pixel in una velocità, usando la frequenza dei fotogrammi del video (fps) e una scala del mondo reale (meter_per_pixel). Regola meter_per_pixel in base alla configurazione della tua fotocamera e usa max_speed per limitare i valori anomali causati da tracciamenti rumorosi.

Stima della velocità con Ultralytics YOLO
# Run a speed example
yolo solutions speed show=True

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

# Adjust meter per pixel value based on camera configuration
yolo solutions speed meter_per_pixel=0.05

Argomenti di SpeedEstimator#

Ecco una tabella con gli argomenti di SpeedEstimator:

ArgomentoTipoPredefinitoDescrizione
modelstrNonePercorso a un file modello Ultralytics YOLO.
fpsfloat30.0Fotogrammi al secondo utilizzati per calcolare la velocità.
max_histint5Numero massimo di punti storici da tracciare per oggetto per calcolare velocità e direzione.
meter_per_pixelfloat0.05Fattore di scala utilizzato per convertire la distanza in pixel in unità del mondo reale.
max_speedint120Velocità massima in km/h; le velocità stimate superiori vengono limitate a questo valore.
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 SpeedEstimator consente di usare i parametri 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.5Imposta 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/unset (FP32) per i modelli PyTorch e TorchScript quando non si usa la CPU; gli altri formati usano la precisione selezionata dal rispettivo artefatto e ambiente di esecuzione. Sostituisce l’argomento deprecato half.

Sono inoltre supportate le seguenti opzioni di visualizzazione:

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_labelsboolTrueMostra le etichette di ogni rilevamento nell'output visivo. Permette di identificare immediatamente gli oggetti rilevati.

Domande frequenti#

  • La stima della velocità degli oggetti con Ultralytics YOLO26 combina il rilevamento degli oggetti e il tracciamento. Il modello rileva gli oggetti in ogni fotogramma, li traccia tra i fotogrammi e converte la distanza percorsa tra un fotogramma e l’altro in una velocità, usando la frequenza dei fotogrammi e la scala meter_per_pixel. L’esempio Python qui sopra esegue l’intera pipeline: passa il tuo video e regola meter_per_pixel in base alla tua fotocamera. Per approfondire, consulta il nostro articolo ufficiale sul blog.

  • L’uso di Ultralytics YOLO26 per la stima della velocità offre notevoli vantaggi nella gestione del traffico:

    • Maggiore sicurezza: stima con precisione la velocità dei veicoli per rilevare quelli che superano i limiti e migliorare la sicurezza stradale.
    • Monitoraggio in tempo reale: sfrutta la capacità di rilevamento degli oggetti in tempo reale di YOLO26 per monitorare efficacemente il flusso del traffico e la congestione.
    • Scalabilità: distribuisci il modello su configurazioni hardware diverse, dai dispositivi edge ai server, per garantire soluzioni flessibili e scalabili per implementazioni su larga scala.

    Per altre applicazioni, consulta i vantaggi della stima della velocità.

  • Sì. YOLO26 è basato su PyTorch e Ultralytics supporta l'esportazione dei modelli YOLO26 in formati come ONNX, TensorRT, CoreML e SavedModel di TensorFlow, per garantire l'interoperabilità con altri framework ML.

    Per esportare un modello YOLO26 nel formato ONNX:

    yolo export model=yolo26n.pt format=onnx

    Scopri di più sull’esportazione dei modelli nella nostra guida all’esportazione.

  • La precisione della stima della velocità con Ultralytics YOLO26 dipende da diversi fattori, tra cui la qualità del tracciamento degli oggetti, la risoluzione e la frequenza dei fotogrammi del video e le variabili ambientali. Il sistema di stima della velocità fornisce stime affidabili, ma potrebbe non essere preciso al 100% a causa delle variazioni nella velocità di elaborazione dei fotogrammi e dell’occlusione degli oggetti.

    Nota: tieni sempre conto del margine di errore e, quando possibile, convalida le stime usando dati di riferimento reali.

Commenti109

Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.

  1. zwxdlutGitHub

    For estimating the speed of passing through a region, I set the "region" parameter while initializing the speed estimator , as follow:

    region_points = [(20, int(h / 2)), (w - 20, int(h / 2))]                      # line points
    # Initialize speed estimation object
    speedestimator = solutions.SpeedEstimator(
        show=True,  # display the output
        model="runs/detect/train/weights/best.pt",  # path to the model file
        fps=fps,  # adjust speed based on frame per second
        # max_speed=120,  # cap speed to a max value (km/h) to avoid outliers
        # max_hist=5,  # minimum frames object tracked before computing speed
        # meter_per_pixel=0.05,  # highly depends on the camera configuration
        classes=[3, 4, 5],  # estimate speed of specific classes.
        # line_width=2,  # adjust the line width for bounding boxes
        region=region_points,
    )
    ```python
    
    The model was customized trained with the VisDrone dataset.
    The speed estimator estimates each object speed whether it is within the region or not. The parameter "region" doesn't take effect at all.
    
    Has the function "estimating speed in regions" not been implemented yet?
  2. t47352GitHub

    I keep getting this error, whether I use reg_pts or line_pts to define the crossing line:

    "ValueError: reg_pts is not a valid solution argument"

    I was initially using Yolo11 with the code in the "Speed Estimation using Ultralytics YOLO" section on this webpage. Then I noticed that the Youtube video on the webpage was with Yolo8, so I changed the model to yolov8m.pt. Everything works with either model as long as I don't add "reg_points" or "line_pts".

    So I tried to use "region=[(200,0), (200,720)]" instead but that didn't seem to do anything. My goal here is to only record speeds of people moving through a certain area/region of the video, not the speed of everyone in the frame. Could this be achieved?

    (FYI, I do not know how to code at all... I've just been copy/pasting things together and then getting Gemini to help me fix stuff where it can.) Thank you!

    1. Glenn JocherUltralytics

      @t47352 reg_pts/line_pts aren’t valid for YOLO11’s solutions.SpeedEstimator; use the documented args (model, fps, meter_per_pixel, etc.) and call it directly, then read per-ID speeds from speed.spd as shown in the guide and API reference.

      import cv2, numpy as np
      from ultralytics import solutions
      
      cap = cv2.VideoCapture("video.mp4")
      fps = cap.get(cv2.CAP_PROP_FPS)
      
      speed = solutions.SpeedEstimator(model="yolo11n.pt", fps=fps, meter_per_pixel=0.05, show=True)
      
      # Optional ROI filter (only keep speeds for boxes whose centroid is inside this polygon)
      roi = np.array([(200,0),(200,720),(400,720),(400,0)], dtype=np.int32)
      
      while cap.isOpened():
          ok, im0 = cap.read()
          if not ok:
              break
          res = speed(im0)  # processes and annotates frame
          speeds_in_roi = {}
          for box, tid in zip(speed.boxes, speed.track_ids):  # xyxy and track ids from last frame
              x1,y1,x2,y2 = map(float, box)
              cx, cy = (x1+x2)/2, (y1+y2)/2
              if cv2.pointPolygonTest(roi, (cx, cy), False) >= 0 and tid in speed.spd:
                  speeds_in_roi[tid] = speed.spd[tid]  # km/h for objects in your area
      • CLI (no ROI filtering):
      yolo solutions speed source="video.mp4" model=yolo11n.pt meter_per_pixel=0.05 show=True

      For supported arguments and examples see the Speed Estimation guide and the SpeedEstimator API reference: Speed Estimation using Ultralytics YOLO11 and SpeedEstimator class reference. If an error persists, please share the exact command and the output of yolo checks.

  3. greviewer-edtGitHub

    Buen día, podrias compartir por favor los link de los videos que estan en este articulo porfa

  4. NawzHGitHub

    If I were to provide a live video feed from a moving vehicle, with the camera facing out the front window, could the speed estimator track the speeds of vehicles approaching and receding?

    I understand this is possible with a stationary setup, but I am curious if the system can handle the added complexity of movement from the capturing vehicle itself?

    1. Glenn JocherUltralytics

      @NawzH the current Ultralytics YOLO11 Speed Estimator assumes a stationary camera setup for accurate speed estimation. For a moving vehicle, additional considerations such as compensating for the camera's motion using GPS or IMU data would be required. This functionality is not natively supported in our implementation but could potentially be developed with custom modifications.

    2. NawzHGitHub

      Hello Glenn, thank you for your response. I plan to use an OBD reader to capture the speed of the recording vehicle and am also now considering incorporating GPS data to aid in the estimation process.

      Since I am exploring the route of custom modifications, could you kindly point me to any guidance or documentation that might assist with integrating GPS and OBD data into the YOLO speed estimator? Any advice or resources would be greatly appreciated!

    3. Glenn JocherUltralytics

      Thank you for your interest! While we don't have direct documentation on integrating GPS and OBD data into the YOLO speed estimator, a possible approach would involve synchronizing GPS/OBD speed data with object tracking outputs to adjust for the capturing vehicle's motion. You may start by modifying the SpeedEstimator class in ultralytics/solutions/speed_estimation.py to incorporate this additional data.

    1. Glenn JocherUltralytics

      @SourceOfNootmite to use speed estimation for other objects like people, trains, or animals, you can specify the desired object classes by setting the classes argument in the SpeedEstimator. For example, classes=[0] for people or classes=[1, 2] for specific vehicles. Refer to Speed Estimation Documentation for detailed examples. Let me know if you need further clarification!

  5. 1024-ZhangGitHub

    Hello, I want to get the speed of each vehicle detected in the speed estimation method and write the vehicle ID and corresponding speed into a csv file. The speed written in the code below is not the speed of each vehicle detected, but the time taken to reason without a frame in the video. I'm using version 8.1.0 of YOLO.

    speeds = [] tracks = model.track(im0, persist=True, show=False) for track in tracks: speed = speed_obj.estimate_speed(im0, track) if speed is not None: speeds.append(track.speed) im0 = speed_obj.estimate_speed(im0, tracks) video_writer.write(im0)

    1. Glenn JocherUltralytics(modificato)

      @1024-Zhang to write the detected vehicle ID and speed into a CSV file, use the speeds returned by the current SpeedEstimator in results.speed_dict ({track_id: km/h}) after each frame:

      import csv
      import time
      
      with open("speeds.csv", "w", newline="") as f:
          writer = csv.writer(f)
          writer.writerow(["timestamp", "id", "speed_kmh"])
          # inside your frame loop
          results = speed_obj(im0)
          for track_id, speed in results.speed_dict.items():
              writer.writerow([time.time(), track_id, speed])

      See the Speed Estimation guide for the full setup. Let me know if you need further clarification!

  6. samkitshah18GitHub

    I believe for the code provided in the guide, we get object speed once it enters the region which is not updated further. For my use case, I have a video of a road with cars and for all the cars in the video I want to continuously track/detect speed throughout the video. Is this feasible using solutions.SpeedEstimator ? If yes, can you provide the code snippet/idea behind this ?

    1. Glenn JocherUltralytics(modificato)

      @samkitshah18 the current solutions.SpeedEstimator computes each tracked object's speed once it has been tracked for max_hist frames, then keeps that speed for the object's ID rather than updating it continuously. If you need continuously updated speeds, you can modify the SpeedEstimator source (ultralytics/solutions/speed_estimation.py) to not lock IDs, or compute speeds yourself from the track history. Keep persist=True tracking so IDs stay consistent. See the Speed Estimation guide for the current arguments. Let us know if you need further clarification!

    2. samkitshah18GitHub(modificato)

      Thank you for your response ! I tried to implement it.

      My code:

      from ultralytics.solutions import speed_estimation
      import cv2
      
      model = YOLO("yolo11n.pt")
      
      video_path = 'Path'
      cap = cv2.VideoCapture(video_path)
      assert cap.isOpened(), "Error opening video file"
      
      fps = int(cap.get(cv2.CAP_PROP_FPS))
      w, h = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
      video_writer = cv2.VideoWriter("speed_estimation8.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
      
      speed_obj = speed_estimation.SpeedEstimator(
          region=[(0, 0), (w, 0), (w, h), (0, h)],
          names=model.names,
          show=True,
      )
      
      object_speeds = {}
      
      while cap.isOpened():
          success, img = cap.read()
          if not success:
              break
      
          tracks = model.track(img, persist=True, show=True, tracker="bytetrack.yaml") 
      
          if tracks is not None:
              updated_tracks = []
              for track in tracks:
                  obj_id = track.id if hasattr(track, 'id') else None
                  if obj_id is not None:
                      if obj_id not in object_speeds:
                          object_speeds[obj_id] = []
      
                      if hasattr(track, 'speed'):
                          object_speeds[obj_id].append(track.speed)
      
                      updated_tracks.append(track)
      
              img = speed_obj.estimate_speed(img)
      
          video_writer.write(img)
      
      cap.release()
      video_writer.release()
      cv2.destroyAllWindows()```
      
      Now it detects 0 speed for all the cars even though it tracks and detects cars.
      
      After Speed Detection: https://streamable.com/67n3f4
      
      Can you please point me what am I missing here ?
    3. Glenn JocherUltralytics(modificato)

      The current SpeedEstimator no longer has a reg_pts argument or a speed region: it estimates the speed of every tracked object across the whole frame, so you don't need to define one. If speeds look wrong, check fps, meter_per_pixel and max_hist against the Speed Estimation guide, and make sure tracking IDs are consistent. Let me know how it goes!

    4. samkitshah18GitHub

      Thank you ! In my use case, I've several videos from varied camera angles so defining the reg_pts is not feasible and I want to track the objects in the entire video and not just a region. Even when I try to narrow down the region, using the persist=True in the above code does not update the speed of vehicles in the above code. Can you please provide any suggestions on how to resolve this ?

    5. Glenn JocherUltralytics(modificato)

      @samkitshah18 the current SpeedEstimator already tracks speeds across the entire frame without a region, and reg_pts is no longer an argument, so there is nothing to disable. If the speed doesn't update, note that each object's speed is calculated after it has been tracked for max_hist frames and then kept for that ID. Verify that frame-to-frame object IDs are consistent, and tune meter_per_pixel and fps for your video. Let us know if you have further issues!

  7. moshiourGitHub

    Hi,

    I would like to write speed using label box. However, the above script for speed estimation does not work. Even, I have already updated yolo11. Please check the above script in examples and here in discussion not same at all.

    In the example above no tracking : speed_obj = solutions.SpeedEstimator( region=[(0, 360), (1280, 360)], model="yolo11n.pt", show=True, )

    while cap.isOpened(): success, im0 = cap.read() if not success: break im0 = speed_obj.estimate_speed(im0) video_writer.write(im0)

    And in the discussion:

    Init speed-estimation obj

    speed_obj = solutions.SpeedEstimator( reg_pts=line_pts, names=names, view_img=True, )

    while cap.isOpened(): success, im0 = cap.read() if not success: print("Video frame is empty or video processing has been successfully completed.") break

    tracks = model.track(im0, persist=True, show=False)
    
    im0 = speed_obj.estimate_speed(im0, tracks)
    video_writer.write(im0)

    ==============================================

    Thank you in advance!

    1. Glenn JocherUltralytics

      @moshiour thank you for your comment. It seems there might be a discrepancy between the examples. Please ensure you're using the correct tracking setup as shown in the discussion. For detailed guidance, refer to our speed estimation documentation at https://docs.ultralytics.com/guides/speed-estimation/. If you have further questions, feel free to ask here.

  8. hardsluggerGitHub

    Hi! I am very glad that you introduced Yolov11 speed estimation module. I am very excited to start working with it. I have a question: Can I estimate speed of the vehicle without drawing the horizontal or vertical line? I am working on speed estimation of vehicles from the images captured by a camera mounted on an autonomous vehicle. Let me know how I can work this out?

    1. Glenn JocherUltralytics(modificato)

      @hardslugger yes, the current SpeedEstimator doesn't require you to draw lines or regions: reg_pts is no longer an argument. It estimates the speed of every tracked object in the frame, so just set fps and a meter_per_pixel scale that fits your camera's perspective. For more details, visit our speed estimation guide.

  9. eps1lonlineGitHub(modificato)

    Hi everyone, how can i add to array the speed of the car that passed the line? here is the code

    import os
    import cv2
    import time
    
    from ultralytics import YOLO, solutions
    
    # Запуск таймера
    start_time = time.time()
    
    # Путь, где будет сохранятся файл
    current_directory = os.getcwd()
    print("The resulting file is saved to the path:", current_directory)
    
    # Загрузка модели YOLOv8
    model = YOLO("yolov8n.pt")
    names = model.model.names
    
    # Открытие видеофайла
    videoFile = "car7.mp4"
    cap = cv2.VideoCapture(videoFile)
    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(
        "speed_estimation.avi",
        cv2.VideoWriter_fourcc(*"mp4v"),
        fps, (w, h))
    
    # Определение линии
    line_pts = [(0, int(h/2)), (int(w), int(h/2))]
    
    # Инициализация объекта оценки скорости
    speed_obj = solutions.SpeedEstimator(reg_pts=line_pts,
                                          names=names,
                                          view_img=True,)
    
    speeds = []
    
    while cap.isOpened():
        success, im0 = cap.read()
        if not success:
            break
        tracks = model.track(im0, persist=True, show=False)
        im0 = speed_obj.estimate_speed(im0, tracks)
        video_writer.write(im0)
        
        print(speed_obj.spdl)
            
    
    # Освобождение ресурсов
    cap.release()
    video_writer.release()
    cv2.destroyAllWindows()
    
    # Время работы программы
    end_time = time.time()
    execution_time = end_time - start_time
    print("Program running time:", int(execution_time//60), " min ", int(execution_time%60), " sec")
    1. Glenn JocherUltralytics(modificato)

      @eps1lonline to add the speed of the car to an array, use the speeds returned by the current SpeedEstimator in results.speed_dict ({track_id: km/h}). Here's a minimal example:

      speeds = {}
      
      while cap.isOpened():
          success, im0 = cap.read()
          if not success:
              break
          results = speed_obj(im0)
          speeds.update(results.speed_dict)  # last known speed per track ID
          video_writer.write(results.plot_im)
      
      print(list(speeds.values()))

      This stores one speed per tracked car.

      -1
    2. eps1lonlineGitHub

      @glenn-jocher, good day.

      I wanted to know the speed of each car in km/h and put it in an array, but after looking at the code, I realized that this is not necessary, because all the speeds of cars can be obtained by accessing the Speed_obj object like this: Speed_obj.spd, we get a dictionary, where the index is the car number, and the value is the speed itself.

      Now I have a couple of other questions:

      1. For movement, we use the formula: U=S/t, where U is the speed of the car; S is the distance traveled by the car; t is time. My object: Speed_obj stores the coordinates along which each car moved, in order to get these coordinates, we must access the object like this: Speed_obj.trk_history. The distance itself is the Euclidean distance, i.e. we find the distance from the starting point to the next point, from this point to another point and so on until we reach the final one. So here's the question, I got that the distance = 600 pixels, how does your model convert pixels into meters, kilometers in order to calculate the speed?

      2. What is Speed_obj.spdl, it stores an array of several dozens that are constantly changing (10, 10, 10, 10, 10, 10...)

      Thank you for your attention!

    3. Glenn JocherUltralytics(modificato)

      @eps1lonline 1. The solution uses a calibration factor, meter_per_pixel, to convert pixels to real-world meters. You'll need to measure a known distance in the video to set this factor accurately.

      1. speed_obj.spdl belonged to an older version and no longer exists. In the current SpeedEstimator, the speeds are returned in results.speed_dict ({track_id: km/h}) each time you call it on a frame. See the speed estimation guide for details.