はじめる

Ultralytics YOLO26による速度推定

速度推定とは?#

速度推定とは、特定の状況における物体の移動速度を計算することで、コンピュータービジョンの用途でよく使われます。Ultralytics YOLO26では、物体トラッキングと距離・時間のデータを組み合わせて物体の速度を計算でき、交通監視や監視業務などに役立ちます。



視聴: Ultralytics YOLO26 による速度推定

速度推定のメリット#

  • 効率的な交通制御: 正確な速度推定は、交通の流れの管理、安全性の向上、道路の渋滞緩和に役立ちます。
  • 高精度な自律走行: 自動運転車などの自律システムでは、信頼性の高い速度推定によって、安全で正確な車両のナビゲーションが可能になります。
  • 監視セキュリティの強化: 監視分析における速度推定は、異常な行動や潜在的な脅威の特定に役立ち、セキュリティ対策の有効性を高めます。

実際の用途#

交通交通
Ultralytics YOLO26による道路上の速度推定Ultralytics YOLO26による橋上の速度推定
Ultralytics YOLO26による道路上の速度推定Ultralytics YOLO26による橋上の速度推定
速度は推定値です

速度は推定値であり、完全に正確とは限りません。また、カメラの仕様や関連要因によって結果は異なります。

YOLO26による速度推定#

SpeedEstimatorソリューションは、各フレームで物体を追跡し、動画のフレームレート(fps)と実世界のスケール(meter_per_pixel)を使用して、ピクセル単位の移動量を速度に変換します。カメラの設定に合わせてmeter_per_pixelを調整し、ノイズの多い追跡結果から外れ値を除外するにはmax_speedを使用してください。

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

SpeedEstimatorの引数#

SpeedEstimatorの引数を以下の表に示します。

引数種類デフォルト説明
modelstrNoneUltralytics YOLOモデルファイルへのパスです。
fpsfloat30.0速度の計算に使用する1秒あたりのフレーム数です。
max_histint5速度や方向の計算で、オブジェクトごとに追跡する履歴ポイントの最大数です。
meter_per_pixelfloat0.05ピクセル距離を実世界の単位に変換するためのスケーリング係数です。
max_speedint120速度の上限(km/h)です。推定速度がこの値を超える場合、この値に制限されます。
line_widthint2Solutionが描画するボックス、キーポイント、カウント表示の線幅です。
verboseboolTrue各フレームの入力shape、クラス数、処理速度を記録するSolutionのログを有効にします。トラッキング呼び出し自体は常にログを出力しません。

SpeedEstimatorソリューションでは、trackパラメーターを使用できます。

引数種類デフォルト説明
trackerstr'tracktrack.yaml'使用するトラッキングアルゴリズムを指定します。組み込みのオプション:botsort.yaml、bytetrack.yaml、ocsort.yaml、deepocsort.yaml、fasttrack.yaml、tracktrack.yaml。
conffloat0.25検出の信頼度しきい値を設定します。値を低くすると、より多くの物体を追跡できますが、誤検出が含まれる可能性があります。
ioufloat0.5重複する検出をフィルタリングするためのIntersection over Union(IoU)しきい値を設定します。
classeslistNoneクラスインデックスで結果をフィルタリングします。たとえば、classes=[0, 2, 3]を指定すると、指定したクラスのみを追跡します。
devicestrNone推論に使用するデバイスを指定します(例:cpu、cuda:0、0)。モデル実行に使用するCPU、特定のGPU、その他の計算デバイスを選択できます。
imgszint or tuple640推論時の入力画像サイズです。正方形の場合は整数、または(height, width)のペアを指定します。形状はモデルのストライドに合わせて調整されます。
max_detint300トラッキング前にフレームごとに保持する検出の最大数です。混雑したシーンでソリューションが処理する物体数を制限します。
quantizeint or strNone推論精度: CPU以外で実行するPyTorchおよびTorchScriptモデルでは、16(FP16)または32/未設定(FP32)を使用します。その他の形式では、アーティファクトとランタイムによって選択される精度が使用されます。非推奨のhalf引数を置き換えます。

さらに、以下の可視化オプションもサポートされています。

引数種類デフォルト説明
showboolFalseTrueの場合、注釈付き画像または動画をウィンドウに表示します。開発やテスト中にすぐ視覚的なフィードバックを得るのに便利です。
show_labelsboolTrue可視化出力で各検出のラベルを表示します。検出されたオブジェクトをすぐに把握できます。

よくある質問#

  • Ultralytics YOLO26による物体の速度推定では、物体検出と追跡を組み合わせます。モデルは各フレーム内の物体を検出してフレーム間で追跡し、フレームレートとmeter_per_pixelスケールを使用して、フレーム間の移動距離を速度に変換します。上記のPythonの例では、この一連の処理を実行できます。動画を渡し、カメラに合わせてmeter_per_pixelを調整してください。詳しくは、公式ブログ記事をご覧ください。

  • 速度推定にUltralytics YOLO26を使用すると、交通管理に大きなメリットがあります。

    • 安全性の向上:車両の速度を正確に推定し、速度超過を検知して道路の安全性を高めます。
    • リアルタイム監視:YOLO26のリアルタイム物体検出機能を活用して、交通の流れや渋滞を効果的に監視できます。
    • スケーラビリティ:エッジデバイスからサーバーまで、さまざまなハードウェア構成にモデルをデプロイできるため、大規模な導入にも柔軟で拡張性の高いソリューションを提供できます。

    その他の用途については、速度推定のメリットをご覧ください。

  • はい。YOLO26はPyTorchを基盤としており、Ultralyticsは他のMLフレームワークとの相互運用性を確保するため、YOLO26モデルをONNX、TensorRT、CoreML、TensorFlow SavedModelなどの形式にエクスポートできます。

    YOLO26モデルをONNX形式にエクスポートするには、次のようにします。

    yolo export model=yolo26n.pt format=onnx

    モデルのエクスポートについて詳しくは、エクスポートガイドをご覧ください。

  • Ultralytics YOLO26による速度推定の精度は、物体追跡の品質、動画の解像度とフレームレート、環境要因など、複数の要因によって異なります。速度推定機能は信頼性の高い推定値を提供しますが、フレーム処理速度のばらつきや物体のオクルージョンにより、100%正確とは限りません。

    注記:常に誤差の範囲を考慮し、可能な場合はグラウンドトゥルースデータを使用して推定値を検証してください。

コメント109

質問したり、結果を共有したり、ほかの人をサポートしたりできます。

  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. 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!

  4. 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(編集済み)

      @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!

  5. 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(編集済み)

      @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(編集済み)

      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(編集済み)

      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(編集済み)

      @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!

  6. 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!

  7. 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(編集済み)

      @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.

  8. eps1lonlineGitHub(編集済み)

    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(編集済み)

      @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(編集済み)

      @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.