はじめる

Ultralytics YOLO26による物体追跡ヒートマップ

Open Heatmaps In Colab

Heatmapソリューションは、Ultralytics YOLO26でビデオフレーム間の物体を追跡し、累積した移動の強度を各フレームに重ねて表示します。そのため、混雑したエリアは暖色に、静かなエリアは寒色に表示されます。YOLO26の物体追跡を基盤とし、単一のPython呼び出しまたはCLIコマンドでビデオを空間アクティビティマップに変換して、交通の流れ、人の移動、滞留エリアを可視化します。



視聴: Ultralytics YOLO26 でヒートマップを作成する方法 | 物体の動きを可視化 | 小売業の VisionAI 🚀

ビデオ分析にヒートマップを使用する理由#

  • アクティビティのパターンをひと目で把握: 追跡対象の物体が滞在した場所に応じて強度が累積するため、フレームを1つずつ手作業で確認しなくても、交通量の多い通路、人気の棚、群衆のボトルネックが明らかになります。
  • 追跡機能を内蔵: ソリューション内部でYOLO26による検出と追跡を実行するため、別個のトラッキングパイプラインを接続する必要はありません。
  • 同じ処理でカウント: regionを渡すと、ヒートマップの生成と同時にゾーンに出入りする物体をカウントでき、1回の実行で2つの分析タスクを組み合わせられます。

実際の活用例#

交通小売
車両交通密度を示すUltralytics YOLOのヒートマップオーバーレイ小売店の顧客の動きを示すUltralytics YOLOのヒートマップオーバーレイ
Ultralytics YOLOによる交通ヒートマップUltralytics YOLOによる小売ヒートマップ

Ultralytics YOLOでヒートマップを生成する方法#

CLIまたはPythonから、ビデオソースに対してHeatmapソリューションを実行します。Pythonの例では、処理済みフレームを出力ビデオファイルに書き込みます。

Ultralytics YOLOによるヒートマップ
# Run a heatmap example
yolo solutions heatmap show=True

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

# Pass a custom colormap
yolo solutions heatmap colormap=cv2.COLORMAP_INFERNO

# Heatmaps + object counting
yolo solutions heatmap region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]"

Heatmap()の引数#

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

引数種類デフォルト説明
modelstrNoneUltralytics YOLOモデルファイルへのパスです。
colormapintcv2.COLORMAP_DEEPGREENヒートマップに使用するカラーマップです。
show_inboolTrue動画ストリームに入場数を表示するかどうかを制御するフラグです。
show_outboolTrue動画ストリームに退場数を表示するかどうかを制御するフラグです。
regionlistまたはdictNone関心領域を定義するポイントです。(x, y)タプルのリスト、または複数領域用に領域名とポイントリストを対応付ける辞書(RegionCounterのみ)を指定します。Noneの場合、領域が必要なSolutionsでは定義済みのデフォルト値が使用されます。
line_widthint2Solutionが描画するボックス、キーポイント、カウント表示の線幅です。
verboseboolTrue各フレームの入力shape、クラス数、処理速度を記録するSolutionのログを有効にします。トラッキング呼び出し自体は常にログを出力しません。

Heatmapソリューションでは、さまざまな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_confboolTrue各検出のラベルとともに信頼度スコアを表示します。各検出に対するモデルの確信度を確認できます。
show_labelsboolTrue可視化出力で各検出のラベルを表示します。検出されたオブジェクトをすぐに把握できます。

ヒートマップのカラーマップ#

colormap引数には、任意のOpenCVカラーマップを指定できます。cv2モジュールの定数(例: colormap=cv2.COLORMAP_INFERNO)を渡します。

カラーマップ名説明
cv2.COLORMAP_AUTUMNAutumnカラーマップ
cv2.COLORMAP_BONEBoneカラーマップ
cv2.COLORMAP_JETJetカラーマップ
cv2.COLORMAP_WINTERWinterカラーマップ
cv2.COLORMAP_RAINBOWRainbowカラーマップ
cv2.COLORMAP_OCEANOceanカラーマップ
cv2.COLORMAP_SUMMERSummerカラーマップ
cv2.COLORMAP_SPRINGSpringカラーマップ
cv2.COLORMAP_COOLCoolカラーマップ
cv2.COLORMAP_HSVHSV(色相、彩度、明度)カラーマップ
cv2.COLORMAP_PINKPinkカラーマップ
cv2.COLORMAP_HOTHotカラーマップ
cv2.COLORMAP_PARULAParulaカラーマップ
cv2.COLORMAP_MAGMAMagmaカラーマップ
cv2.COLORMAP_INFERNOInfernoカラーマップ
cv2.COLORMAP_PLASMAPlasmaカラーマップ
cv2.COLORMAP_VIRIDISViridisカラーマップ
cv2.COLORMAP_CIVIDISCividisカラーマップ
cv2.COLORMAP_TWILIGHTTwilightカラーマップ
cv2.COLORMAP_TWILIGHT_SHIFTEDShifted Twilightカラーマップ
cv2.COLORMAP_TURBOTurboカラーマップ
cv2.COLORMAP_DEEPGREENDeep Greenカラーマップ

ヒートマップの仕組み#

ヒートマップソリューションは、ObjectCounterクラスを拡張したものです。最初に処理したフレームで、フレームサイズに合わせた空の強度レイヤーを作成します。その後、各フレームを次の2つのステップで処理します。

  1. YOLO26のトラッキングで、フレーム内のすべてのオブジェクトを検出し、追跡します
  2. 追跡対象の各オブジェクトについて、バウンディングボックスの中心を基準とする円形領域内のヒートマップ強度を高めます

フレームごとに1回、蓄積した強度レイヤーを正規化し、選択したカラーマップで色付けして、元のフレームとブレンドします。少なくとも1つのオブジェクトを追跡するとオーバーレイが表示され、それまではヒートマップのオーバーレイなしでフレームが表示されます。

その結果、時間の経過とともに形成される動的なビジュアライゼーションにより、動画データ内の交通パターン、群衆の移動、その他の空間的な動きを把握できます。regionを設定すると、ヒートマップの形成と同時に、その領域に出入りするオブジェクトもカウントします。

結論#

Ultralytics YOLO26のヒートマップソリューションは、数行のコードでオブジェクトトラッキングの結果を直感的なアクティビティオーバーレイに変換します。さらに活用するには、オブジェクトカウントと組み合わせたり、その他のUltralytics Solutionsを確認したり、基盤となるトラッキングモードについて読んだりできます。

よくある質問#

  • Ultralytics YOLO26は、動画フレーム間でオブジェクトを追跡し、追跡した各オブジェクトの位置に強度値を蓄積してから、結果を色付けし、元のフレームとブレンドすることでヒートマップを生成します。オブジェクトが頻繁に現れる場所や長く留まる場所では強度が高まり、より暖色系で表示されます。設定オプションについては、Heatmap()の引数セクションを参照してください。

  • メインの例に示すように、OpenCVのcv2.VideoWriterを使用して、処理した各フレームでresults.plot_imを書き込みます。plot_im属性には、ヒートマップのオーバーレイが適用済みのフレームが格納されています。

  • はい。線、長方形、またはポリゴンの点を指定したregion引数をHeatmap()に渡すと、ヒートマップの形成と同時に、その領域に出入りするオブジェクトをカウントします。返される結果には、in_count、out_count、クラスごとのカウントが含まれます。領域の設定方法については、オブジェクトカウントのガイドを参照してください。

  • 残すクラスのインデックスを指定して、classes引数をHeatmap()に渡します。たとえば、classes=[0, 2]を指定すると、人物と車(COCOクラスインデックス0と2)のみを使ってヒートマップを作成します。

    import cv2
    
    from ultralytics import solutions
    
    cap = cv2.VideoCapture("path/to/video.mp4")
    heatmap = solutions.Heatmap(show=True, model="yolo26n.pt", classes=[0, 2])
    
    while cap.isOpened():
        success, im0 = cap.read()
        if not success:
            break
        results = heatmap(im0)
    cap.release()
    cv2.destroyAllWindows()
  • Ultralytics YOLO26のヒートマップは、物体検出、トラッキング、強度の累積、オーバーレイ描画を単一の呼び出しに統合します。一方、OpenCVやMatplotlibなどの汎用ツールでは、このパイプラインを自分で構築する必要があります。このソリューションは動画ストリームをリアルタイムで処理し、永続的なトラッキングとカスタマイズ可能なカラーマップを標準でサポートします。

コメント65

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

  1. RizwanMunawarGitHub

    🎉 Big News Alert! 🚀 Ultralytics Solutions CLI is here from ultralytics>=8.3.28! Now, you can easily harness the power of advanced YOLO solutions straight from the command line. Simplify your workflow, and streamline object detection, tracking, counting, and more—all with just a few commands! Get ready to experience a whole new level of efficiency! 💥

    CLI Usage Overview

    yolo SOLUTIONS SOLUTION_NAME ARGS
    • SOLUTIONS is a mandatory keyword.
    • SOLUTION_NAME (optional): Choose from ['count', 'heatmap', 'queue', 'speed', 'workout', 'analytics'].
    • ARGS (optional): Use custom arg=value pairs, like show_in=True, to customize settings.

    Examples

    yolo solutions heatmap show=True  # For object counting
    
    yolo solutions heatmap source="path/to/video/file.mp4"  # Specify a video file path

    Start exploring now and let Ultralytics Solutions CLI power up your projects!

    4
    1. Glenn JocherUltralytics(編集済み)

      Yes, applying heatmaps to instance segmentation is feasible and offers a vivid way to visualize the density and distribution of detected objects across video frames 🌈. The Heatmap solution runs tracking itself with whatever model you give it, including a segmentation model, and accumulates intensity around each tracked object's bounding box (the masks themselves are not used). Here's a simplified example:

      import cv2
      
      from ultralytics import solutions
      
      cap = cv2.VideoCapture("path/to/video.mp4")
      assert cap.isOpened(), "Failed to open video file or stream!"
      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("heatmap_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
      
      # Initialize your heatmap object with a segmentation model
      heatmap = solutions.Heatmap(show=True, model="yolo26n-seg.pt", colormap=cv2.COLORMAP_PARULA)
      
      # Process video frames
      while cap.isOpened():
          success, frame = cap.read()
          if not success:
              break  # Exit loop if no more frames
      
          results = heatmap(frame)
          video_writer.write(results.plot_im)
      
      cap.release()
      video_writer.release()
      cv2.destroyAllWindows()

      This snippet performs tracking with an instance segmentation model on video frames and overlays the accumulated heatmap. Remember, the success of applying heatmaps heavily relies on the quality of your model, so ensure it has been adequately trained or fine-tuned for your instance segmentation task. Happy visualizing! 🚀

    2. Paula DerrengerUltralytics(編集済み)

      Yes, applying heatmaps to instance segmentation is feasible and offers a vivid way to visualize the density and distribution of detected objects across video frames 🌈. The Heatmap solution tracks objects with the model you provide, including a segmentation model, and overlays the accumulated activity on each frame. It builds the heatmap from the tracked objects' bounding boxes rather than the masks.

      Here's a simplified example:

      import cv2
      
      from ultralytics import solutions
      
      # Initialize video capture
      cap = cv2.VideoCapture("path/to/your/video.mp4")
      assert cap.isOpened(), "Error reading video file"
      
      # Video writer setup
      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("segmentation_heatmap.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
      
      # Initialize heatmap with a segmentation model
      heatmap = solutions.Heatmap(show=True, model="yolo26n-seg.pt", colormap=cv2.COLORMAP_JET)
      
      while cap.isOpened():
          success, im0 = cap.read()
          if not success:
              break
      
          # Track objects and generate the heatmap overlay
          results = heatmap(im0)
      
          # Write heatmap output
          video_writer.write(results.plot_im)
      
      # Cleanup
      cap.release()
      video_writer.release()
      cv2.destroyAllWindows()

      Feel free to experiment with different configurations, such as colormap, to meet your specific visualization needs. Happy coding! 🚀

    3. Arjunpixel28GitHub

      Hi ,

      heatmap_obj = heatmap.Heatmap(view_img=False, imw=w, imh=h, heatmap_alpha=0.5, colormap=cv2.COLORMAP_JET)
      TypeError: Heatmap.__init__() got an unexpected keyword argument 'view_img'

      when i tried to run this i got this error !

    4. Paula DerrengerUltralytics(編集済み)

      Hey there! 👋 It looks like you encountered an unexpected view_img argument error. I'm here to help!

      This happens because the view_img argument no longer exists in the Heatmap solution; it was replaced by show. Update your Ultralytics library and use the current arguments:

      heatmap = solutions.Heatmap(show=True, model="yolo26n-seg.pt", colormap=cv2.COLORMAP_JET)

      To update the library, run:

      pip install ultralytics --upgrade

      That should do the trick! Keep us posted if you run into any more issues or need further assistance. Happy coding! 🚀

    5. Arjunpixel28GitHub

      I Tried upgrading the ultralytics also its giving same attribute error heatmap_obj = heatmap.Heatmap(imw=w, imh=h, heatmap_alpha=0.5, colormap=cv2.COLORMAP_JET) TypeError: Heatmap.init() got an unexpected keyword argument 'imw'

    6. Paula DerrengerUltralytics(編集済み)

      @Arjunpixel28 hi there! 👋 It seems there's a mix-up with the initialization arguments for the Heatmap class. You don't need to specify imw and imh, because the frame size is taken from the frames you process. In current versions, initialize it like this:

      heatmap = solutions.Heatmap(model="yolo26n.pt", colormap=cv2.COLORMAP_JET, show=True)
      results = heatmap(frame)  # annotated image is in results.plot_im

      See the Heatmaps guide for the full list of arguments. This setup should work without errors. Should you face any more issues or have further questions, feel free to reach out! 🚀

    7. Arjunpixel28GitHub

      Hi Paula Derrenger,

      in the earlier response you had only given the parameters of imw and imh and now your saying it should not be used and even now its not working still have issue with that.

      heatmap_obj = heatmap.Heatmap(colormap=cv2.COLORMAP_JET, heatmap_alpha=0.5) TypeError: Heatmap.init() got an unexpected keyword argument 'colormap'

      I just asked a simple thing to apply heat map on instance segmentation since so many days you guys have not sloved that

    8. Paula DerrengerUltralytics(編集済み)

      @Arjunpixel28 hey there! I understand your concern and appreciate your patience. The Heatmap settings are now passed when you create the object (there is no separate set_args()), and the object is called directly on each frame, running tracking itself:

      import cv2
      
      from ultralytics import solutions
      
      cap = cv2.VideoCapture("path/to/video.mp4")
      assert cap.isOpened(), "Error reading video file"
      
      # Settings such as colormap are set at initialization
      heatmap = solutions.Heatmap(model="yolo26n.pt", colormap=cv2.COLORMAP_PARULA)
      
      while cap.isOpened():
          success, frame = cap.read()
          if not success:
              break
      
          results = heatmap(frame)
          cv2.imshow("Heatmap", results.plot_im)
          if cv2.waitKey(1) & 0xFF == ord("q"):
              break
      
      cap.release()
      cv2.destroyAllWindows()

      See the Heatmaps guide for all available arguments. If you encounter other issues, please let us know! 🚀

    9. Arjunpixel28GitHub

      frame_with_heatmap = heatmap_obj.generate_heatmap(frame, tracks) File "/usr/local/lib/python3.10/dist-packages/ultralytics/solutions/heatmap.py", line 163, in generate_heatmap self.heatmap *= self.decay_factor # decay factor TypeError: unsupported operand type(s) for *=: 'NoneType' and 'float' and again i got this error Type error

    10. Paula DerrengerUltralytics(編集済み)

      @Arjunpixel28 hey there! 👋 It looks like you're encountering a TypeError related to the initialization of the Heatmap object. Sorry for the confusion caused by previous responses. The Heatmap class lives in ultralytics.solutions (it is not importable from ultralytics directly), and arguments such as colormap and show are passed when you create it. The object is then called on each frame:

      import cv2
      
      from ultralytics import solutions
      
      cap = cv2.VideoCapture("path/to/your/video.mp4")
      assert cap.isOpened(), "Failed to open video."
      
      heatmap = solutions.Heatmap(model="yolo26n.pt", colormap=cv2.COLORMAP_JET)
      
      while True:
          ret, frame = cap.read()
          if not ret:
              break  # Exit loop if no more frames
      
          results = heatmap(frame)  # tracking and heatmap overlay in one call
          cv2.imshow("Heatmap Visual", results.plot_im)
          if cv2.waitKey(10) == ord("q"):
              break
      
      cap.release()
      cv2.destroyAllWindows()

      If you're still facing issues, check your Ultralytics version with pip show ultralytics and upgrade with pip install -U ultralytics. Thanks for your patience, and we're here to help get you through this!

    11. Arjunpixel28GitHub

      from ultralytics import YOLO, Heatmap ImportError: cannot import name 'Heatmap' from 'ultralytics' (/home/safepro/.local/lib/python3.10/site-packages/ultralytics/init.py)

    12. Paula DerrengerUltralytics(編集済み)

      Hey there! 🌟 It looks like you've encountered an import error when trying to use Heatmap from the ultralytics package.

      The heatmap functionality is part of the ultralytics.solutions module. The current import is:

      from ultralytics import solutions
      
      heatmap = solutions.Heatmap(model="yolo26n.pt", show=True)

      If solutions is not recognized, your installed version is likely too old. Update to the latest version using pip:

      pip install ultralytics --upgrade

      See the Heatmaps guide for a full example. Thanks for your understanding, and feel free to reach out with any more questions! 🚀

  2. hariouatGitHub

    Hello everyone,

    Please, how to generate heatmaps for classification model with yolov11?

    Thanks in advance for your reply.

    1
    1. Glenn JocherUltralytics

      Thank you for your question! Currently, heatmap generation in Ultralytics YOLO11 is supported for object detection tasks and not directly for classification models. If you're specifically looking to visualize classification results, you might need to adapt custom visualization techniques using libraries like Matplotlib or OpenCV. For more details on heatmap usage, visit the documentation.

    1. hnyllGitHub

      also is it possible to choose what "class" or thing i want to create a heatmap of?

    2. Glenn JocherUltralytics(編集済み)

      @hnyll to generate a heatmap for a single image with a YOLO model, create the Heatmap solution with your model and call it on the image, then use the annotated result:

      import cv2
      
      from ultralytics import solutions
      
      heatmap = solutions.Heatmap(model="yolo26n.pt", show=False)
      results = heatmap(cv2.imread("path/to/image.jpg"))
      cv2.imwrite("heatmap_result.jpg", results.plot_im)

      Heatmaps build up intensity over time, so a single image gives only a snapshot of the detected objects. To restrict it to specific classes, pass classes=[...] when creating Heatmap. For more details, please refer to the Ultralytics heatmap guide.

    3. hnyllGitHub(編集済み)

      thanks for the reply. i found out how to do heatmap on single images. i just wasnt looking carefully enough. do you happen to know where i can find more information about what the classes represent? im not sure that i could find it on the Ultralytics heatmap guide. for example what classes 12 and 18 when i do

      heatmap = solutions.Heatmap( show=True, model="yolo11n.pt", colormap=cv2.COLORMAP_PARULA, classes=[12,18] )

      also is there any way that i can add a class by training a model or something? i wanted to create heatmaps on something that probably isnt in the list of classes in the pretrained yolo model.

    4. Glenn JocherUltralytics

      For class information, you can refer to the dataset's YAML file used during training, which lists all class names. To add a new class, you'll need to retrain the model with a dataset that includes the new class.

  3. JaykhokharaGitHub

    Have you ever tried tracking short video segments (for example, 10-minute chunks) from the same camera based on timestamps, and then combining the heatmaps using those timestamps — such as merging 6 chunks (10 minutes each) to create a 1-hour heatmap? I tried saving the heatmap data in JSON, but the file becomes very large and slow to load. Storing the data in .npy works, but using it at scale or in a larger platform isn’t very practical. Do we have any recommended approach or solution for this in Ultralytics?

    1. Glenn JocherUltralytics

      Yes—rather than JSON, the scalable approach is to persist the underlying accumulated raster (heatmap.heatmap, a NumPy array) and merge by summing arrays (same camera/resolution), then normalize/visualize once at the end; you can either keep a single solutions.Heatmap instance alive across your 10‑minute chunks, or save/load the array between runs (see the Heatmaps guide and the Heatmap solution reference).

      import numpy as np
      import cv2
      from ultralytics import solutions
      
      heatmap = solutions.Heatmap(model="yolo26n.pt", show=False, colormap=cv2.COLORMAP_PARULA)
      
      # ...process a 10-min chunk...
      # results = heatmap(im0)  # call per-frame
      
      # save compactly (much smaller than JSON)
      np.savez_compressed("cam1_2026-01-18T1200Z.npz", heatmap=heatmap.heatmap.astype(np.float32))
      
      # later: merge multiple chunks (1-hour heatmap)
      merged = None
      for f in ["cam1_2026-01-18T1200Z.npz", "cam1_2026-01-18T1210Z.npz", "cam1_2026-01-18T1220Z.npz"]:
          h = np.load(f)["heatmap"]
          merged = h if merged is None else (merged + h)

      If you share what “at scale” means for your platform (e.g., cloud object storage, DB constraints, expected camera count), reply here in this discussion with a bit more detail and we can suggest the best storage format (e.g., chunked zarr/HDF5 vs compressed npz).

    1. Glenn JocherUltralytics

      Los videos de ejemplo específicos mostrados en la documentación no están disponibles para descarga directa. Sin embargo, puedes usar cualquier video para probar la funcionalidad de heatmaps con YOLO11:

      # Usar tu propio video
      yolo solutions heatmap source="path/to/tu_video.mp4" show=True
      
      # O usar videos de ejemplo disponibles públicamente
      # Prueba con videos de tráfico, multitudes, o cualquier escena con movimiento

      También puedes encontrar videos de prueba gratuitos en sitios como Pixabay o usar tu cámara web con source=0 para testing en tiempo real.

    1. Glenn JocherUltralytics

      @haiyuou thanks for your interest in YOLO11! The current heatmap implementation is designed for video tracking applications, but you can adapt it for single image detection by using the same Heatmap solution with static images. Please continue the discussion here on GitHub rather than via email so the entire community can benefit from the solutions.

    1. Glenn JocherUltralytics(編集済み)

      @reigngers15 To generate a heatmap visualization for a specific image, you can adapt the solutions approach with a few modifications:

      import cv2
      
      from ultralytics import solutions
      
      # Load your image
      image = cv2.imread("path/to/your/image.jpg")
      
      # Initialize heatmap object
      heatmap = solutions.Heatmap(
          show=True,
          model="yolo26n.pt",
          colormap=cv2.COLORMAP_PARULA,
          # classes=[0, 2],  # Optional: specify classes for heatmap
      )
      
      # Process the image with the heatmap (runs the model internally)
      results = heatmap(image)
      
      # Display or save the result
      cv2.imshow("Heatmap", results.plot_im)
      cv2.waitKey(0)
      cv2.imwrite("heatmap_result.jpg", results.plot_im)

      Since heatmaps typically build up intensity over time across video frames, for a single image you'll get a snapshot visualization of detected objects. If you need more visualization control, you can find additional information in our heatmaps documentation.

    2. reigngers15GitHub

      how about in this code, can i add or change the size of heatmap?

      Initialize heatmap object

      heatmap = solutions.Heatmap( show=True, model=model, # Pass the model directly colormap=cv2.COLORMAP_PARULA, # classes=[0, 2], # Optional: specify classes for heatmap size=15 (if px) )

    3. Glenn JocherUltralytics

      @reigngers15 Currently, the Heatmap class in YOLO11 doesn't have direct parameters for changing the size or shape of the heatmap points from circles to squares. The heatmap implementation uses a radius-based approach to create circular effects around detected objects.

      If you need to customize the size or shape of the heatmap, you would likely need to modify the heatmap_effect method in the source code. This method is responsible for calculating the area of effect for each detection.

      Here's what you could potentially do:

      1. For changing the size: You might need to fork the repository and modify the calculation in the heatmap_effect method to adjust the radius used.

      2. For changing to a square shape: You would need to replace the circular distance calculation with a square boundary check.

      For advanced customizations like these, I recommend checking out the source code in the ultralytics/solutions/heatmap.py file and making your own modified version.

      If you need further guidance on specific implementation details, feel free to ask!

      1
    1. Glenn JocherUltralytics(編集済み)

      @fangyuZ1025 the Heatmap solution accumulates the locations of tracked objects, so it needs a model that outputs bounding boxes: a detection model (for example yolo26n.pt) or a segmentation model (for example yolo26n-seg.pt), which you pass as model= when you create solutions.Heatmap(...). Classification models (-cls) produce no object locations, so a heatmap can't be built from them. Refer to the Heatmaps guide for detailed examples and configurations. Let me know if you need further clarification!

    2. fangyuZ1025GitHub

      Sorry, I think I didn't express what I meant. I am working on the heat map of yolov8 to explain the interpretability of the model. This code is doing the heat map of the video tracking task, and I want to implement my image heat map feature detection based on it. I wonder if there is any relevant code. Thanks again for your reply

    3. Glenn JocherUltralytics(編集済み)

      Thank you for clarifying! To produce a heatmap for static images, you can use the same Heatmap solution and call it on an image: results = heatmap(image) returns a results object with the overlay in results.plot_im. Note that generate_heatmap no longer exists. For further guidance, refer to the heatmap.py implementation. Let us know if you need further assistance!

  4. Halibo01GitHub

    Hello, I'm trying to apply a heatmap using a classification model in YOLOv8, but I'm encountering an issue. The error message I receive is: 'AttributeError: 'NoneType' object has no attribute 'cpu'. Is there a known solution to this?

    1. Glenn JocherUltralytics

      @Halibo01 it seems like the error might be due to an issue with the tracking results. Please ensure you are using the latest version of the Ultralytics package. If the issue persists, double-check that the model and input data are correctly loaded and processed. For more detailed guidance, refer to the Heatmaps Guide.

    2. Glenn JocherUltralytics

      @Halibo01 it looks like you're encountering an issue with the classification model in YOLOv8. The error 'AttributeError: 'NoneType' object has no attribute 'cpu'' typically indicates that a variable expected to hold a tensor is actually None. Please ensure that your model's output is correctly assigned and not None before calling .cpu(). Additionally, verify that you are using the latest version of the Ultralytics package. For further details on heatmaps, you can refer to the Ultralytics Heatmaps Guide.