Ultralytics YOLOによるモデル予測
はじめに#
機械学習やコンピュータービジョンでは、トレーニング済みモデルで視覚データを解釈することを推論または予測と呼びます。Ultralytics YOLO26のPredictモードは、幅広いデータソースで高速なリアルタイム推論を実行します。
今後の推論例については、未公開のYOLO27プレビューを参照してください。
視聴: PythonでUltralytics YOLO26を使ってバウンディングボックス、マスク、キーポイント、OBB、深度などを抽出する方法 🚀
実世界での活用例#
| 製造 | スポーツ | 安全 |
|---|---|---|
| 車両用スペアパーツの検出 | サッカー選手の検出 | 人の転倒検出 |
Ultralytics YOLOを推論に使用する理由#
YOLO26のPredictモードを使用する主な理由:
- 汎用性: 画像、動画、ライブストリームで推論を実行できます。
- パフォーマンス: 精度を損なうことなく、リアルタイムの高速処理を実現できるように設計されています。
- 使いやすさ: 直感的に使えるPythonおよびCLIインターフェースにより、迅速なデプロイとテストが可能です。
- 高いカスタマイズ性: さまざまな設定やパラメーターを調整して、特定の要件に合わせてモデルの推論動作をカスタマイズできます。
- 本番環境に対応: モデルをUltralytics Platformの推論エンドポイントとしてデプロイし、自動スケーリングとモニタリングを利用するか、ローカルで推論を実行できます。
predictモードの主な機能#
YOLO26のPredictモードの機能:
- さまざまなデータソースとの互換性: Predictモードでは、単一画像、画像の集合、動画ファイル、リアルタイム動画ストリームを入力として使用できます。
- ストリーミングモード: ストリーミング機能を使用して、メモリ効率に優れた
Resultsオブジェクトのジェネレーターを生成できます。predictorのcallメソッドでstream=Trueを設定すると有効になります。すべての結果を含むリストを返すデフォルトの動作(stream=False)とは異なり、stream=Trueは結果を1つずつ返すため、長時間の動画やライブストリームに特に役立ちます。 - バッチ処理: 複数の画像や動画フレームを1つのバッチで処理することで、推論時間をさらに短縮できます。
- 統合のしやすさ: 柔軟なAPIを通じて、既存のデータパイプラインやその他のソフトウェアコンポーネントに統合できます。
Ultralytics YOLOモデルは、推論時にstream=Trueをモデルに渡すと、ResultsオブジェクトのPythonリスト、またはメモリ効率に優れたResultsオブジェクトのジェネレーターを返します。
from ultralytics import YOLO
# モデルを読み込む
model = YOLO("yolo26n.pt") # 事前学習済みYOLO26nモデル
# 画像のリストに対してバッチ推論を実行
results = model(["image1.jpg", "image2.jpg"]) # Resultsオブジェクトのリストを返す
# 結果のリストを処理
for result in results:
boxes = result.boxes # バウンディングボックス出力用のBoxesオブジェクト
masks = result.masks # セグメンテーションマスク出力用のMasksオブジェクト
keypoints = result.keypoints # ポーズ出力用のKeypointsオブジェクト
probs = result.probs # 分類出力用のProbsオブジェクト
obb = result.obb # OBB出力用のOriented boxesオブジェクト
result.show() # 画面に表示
result.save(filename="result.jpg") # ディスクに保存推論ソース#
YOLO26は、以下の表に示すように、さまざまな種類の入力ソースを推論に使用できます。ソースには、静止画像、動画ストリーム、さまざまなデータ形式が含まれます。また、各ソースをstream=True ✅引数を指定したストリーミングモードで使用できるかどうかも示しています。ストリーミングモードでは、すべてのフレームをメモリに読み込む代わりに結果のジェネレーターを作成するため、動画やライブストリームの処理に適しています。
長時間の動画や大規模なデータセットを処理する場合は、メモリを効率的に管理するためにstream=Trueを使用してください。stream=Falseの場合、すべてのフレームまたはデータポイントの結果がメモリに保存されるため、大きな入力ではすぐにメモリ使用量が増加し、メモリ不足エラーが発生する可能性があります。一方、stream=Trueはジェネレーターを使用し、現在のフレームまたはデータポイントの結果のみをメモリに保持するため、メモリ消費量を大幅に削減し、メモリ不足の問題を防止できます。
| ソース | 例 | 種類 | 備考 |
|---|---|---|---|
| 画像 | 'image.jpg' | strまたはPath | 単一の画像ファイル。 |
| URL | 'https://ultralytics.com/images/bus.jpg' | str | 画像のURL。 |
| スクリーンショット ✅ | 'screen' | str | 停止するまで画面を継続的にキャプチャします。 |
| PIL | Image.open('image.jpg') | PIL.Image | RGBチャンネルを含むHWC形式。 |
| OpenCV | cv2.imread('image.jpg') | np.ndarray | BGRチャンネルを含むHWC形式uint8 (0-255)。 |
| NumPy | np.zeros((640,1280,3)) | np.ndarray | BGRチャンネルを含むHWC形式uint8 (0-255)。 |
| torch | torch.zeros(16,3,320,640) | torch.Tensor | RGBチャンネルを含むBCHW形式float32 (0.0-1.0)。 |
| CSV | 'sources.csv' | strまたはPath | 画像、動画、またはディレクトリへのパスを含むCSVファイル。 |
| 動画 ✅ | 'video.mp4' | strまたはPath | MP4、AVIなどの形式の動画ファイル。 |
| ディレクトリ ✅ | 'path/' | strまたはPath | 画像または動画を含むディレクトリへのパス。 |
| glob ✅ | 'path/*.jpg' | str | 複数のファイルに一致するglobパターン。ワイルドカードとして*文字を使用します。 |
| YouTube ✅ | 'https://youtu.be/LNwODJXcvt4' | str | YouTube動画のURL。 |
| ストリーム ✅ | 'rtsp://example.com/media.mp4' | str | RTSP、RTMP、TCPなどのストリーミングプロトコルのURL、またはIPアドレス。 |
| マルチストリーム ✅ | 'list.streams' | strまたはPath | 1行につき1つのストリームURLを含む*.streamsテキストファイルです。たとえば、8つのストリームをバッチサイズ8で実行します。 |
| Webカメラ ✅ | 0 | int | 推論を実行する接続済みカメラデバイスのインデックス。 |
以下は、各ソースタイプを使用するコード例です。
from ultralytics import YOLO
# 事前学習済みYOLO26nモデルを読み込む
model = YOLO("yolo26n.pt")
# 画像ファイルへのパスを定義
source = "path/to/image.jpg"
# ソースに対して推論を実行
results = model(source) # Resultsオブジェクトのリスト推論引数#
model.predict() は、デフォルト設定を上書きするために推論時に渡せる複数の引数を受け付けます。
固定形状と最小矩形(rect)#
デフォルトでは、predict は rect=True を使用し、可能であれば 最小矩形 パディングを有効にします。画像は imgsz の内側に収まるように拡大縮小され、最も近いストライドの倍数までのみパディングされるため、最終的なテンソルは imgsz より 小さく なる場合があります。最小矩形パディングは、バッチ内のすべての画像の形状が同じで、バックエンドが対応している場合(PyTorch .pt、または動的 ONNX などの動的形状エクスポートの場合)にのみ使用されます。それ以外の場合、画像は 完全な imgsz の目標サイズまでパディングされます。Depth モデルと RT-DETR モデルでは rect は無視され、すべての画像がパディングなしで完全な imgsz に引き伸ばされます。
rect=False を使用すると、常に完全な imgsz の目標サイズが使用されます。エクスポート済みモデル(ONNX、TensorRT など)に合わせて固定の入力サイズが必要な場合におすすめです。
整数とタプル imgsz
- 整数 の
imgsz=640は、ストライドに合わせて丸められた後、正方形のターゲット(640, 640)になります。 - タプル の
imgsz=(384, 672)は、長方形のターゲットを設定します。rect=Trueを使用すると、実際のテンソルはこのターゲットより小さくなる場合があります。
トレーニングとpredict/export
トレーニングで受け付けるのは単一の整数 imgsz のみです([h, w] リストは最大値に変換されます)。Predictとexportでは、整数または (height, width) タプルを使用できます。
from ultralytics import YOLO
# 事前学習済みYOLO26nモデルを読み込む
model = YOLO("yolo26n.pt")
# 'bus.jpg'で引数を指定して推論を実行します
model.predict("https://ultralytics.com/images/bus.jpg", save=True, imgsz=320, conf=0.25)推論引数:
| 引数 | 種類 | デフォルト | 説明 |
|---|---|---|---|
source | str、int、またはNone | None | 推論のデータソースを指定します。画像パス、動画ファイル、ディレクトリ、URL、またはライブ配信用のデバイスIDを指定できます。省略すると警告がログに記録され、組み込みのデモアセット(ultralytics/assets、またはOBBの場合はデモURL)がモデルで使用されます。幅広い形式とソースに対応しているため、さまざまな種類の入力に柔軟に適用できます。 |
conf | float | 0.25 | 検出の最小信頼度しきい値を設定します。このしきい値を下回る信頼度で検出された物体は無視されます。この値を調整すると、誤検出を減らせる場合があります。 |
iou | float | 0.5 | 非最大抑制(NMS)に使用する積集合対和(IoU)のしきい値です。値を小さくすると、重なり合うボックスが除外されて検出数が減り、重複の削減に役立ちます。 |
imgsz | intまたはtuple | 640 | レターボックスの目標サイズです。整数を指定すると正方形のN×Nになり、タプルを指定すると(height, width)になります。rect=Trueの場合、最小矩形パディングにより実際のテンソルが目標サイズより小さくなることがあります。固定サイズにするにはrect=Falseを使用してください。固定形状と最小矩形をご覧ください。 |
rect | bool | True | True の場合、可能であれば最小矩形パディングを使用します(バッチ内で同じ形状であり、バックエンドが対応している場合)。False の場合は、常に完全な imgsz を使用します。固定形状と最小矩形の比較をご覧ください。depth と RT-DETR モデルでは無視され、画像はパディングなしで完全な imgsz に引き伸ばされます。 |
quantize | intまたはstr | None | 推論精度: 16/"fp16"および32/"fp32"/未設定では、PyTorchおよびTorchScriptモデルの演算にFP16またはFP32を選択します(CPUではFP32)。その他の形式では、アーティファクトとランタイムによって選択される精度が使用されます。16では、OpenVINOは引き続きクライアント側で入力をFP16に丸めてからFP32に戻しますが、ランタイムの精度は変更しません。INT8/PTQ量子化はエクスポート時に設定し、その後、エクスポート済みモデルの読み込み時に使用します。非推奨のhalfフラグを置き換えます。 |
device | str | None | 推論に使用するデバイスを指定します(例: cpu、cuda:0、0、npu、npu:0)。モデルの実行に使用するCPU、特定のGPU、Huawei Ascend NPU、その他の演算デバイスを選択できます。OpenVINOモデルとLiteRTモデルは、Intel GPUおよびNPU上でxpuとnpuを実行します。各フォーマットの詳細については、推論デバイスをご覧ください。 |
dnn | bool | False | Trueの場合、ONNXモデルの推論にONNX RuntimeではなくOpenCV DNNモジュールを使用します。 |
data | str | None | データセットYAMLへのパス(例: coco8.yaml)。読み込んだモデル自体にクラス名がない場合に限り、そのnamesだけを読み取ります。該当するのは、サードパーティによるエクスポートモデル、または付属のメタデータから切り離されたUltralyticsエクスポートモデルです。このようなモデルは、それ以外の場合、class0、class1などを出力します。 |
batch | int | 1 | 推論のバッチサイズを指定します(ディレクトリ、動画ファイル、または.txtファイルをソースにする場合のみ有効です)。バッチサイズを大きくするとスループットが向上し、推論にかかる合計時間を短縮できます。 |
tile | boolまたはint | False | 固定サイズのタイルで推論を実行し、元画像の座標系で出力を返します。True は imgsz を使用します。正の整数を指定するとタイルサイズが設定されます。高解像度タイル分割をご覧ください。 |
max_det | int | 300 | 画像ごとに許可される検出数の最大値です。1回の推論でモデルが検出できるオブジェクトの総数を制限し、密集したシーンで過剰な出力が発生するのを防ぎます。 |
vid_stride | int | 1 | 動画入力のフレームストライドです。動画のフレームをスキップして処理を高速化しますが、時間解像度は低下します。値が1の場合はすべてのフレームを処理し、値を大きくするとフレームをスキップします。 |
stream_buffer | bool | False | 動画ストリームの受信フレームをキューに格納するかどうかを指定します。Falseの場合、新しいフレームを受け入れるために古いフレームを破棄します(リアルタイムアプリケーション向けに最適化されています)。Trueの場合、新しいフレームをバッファーにキューイングしてフレームのスキップを防ぎますが、推論FPSがストリームFPSより低いと遅延が発生します。 |
visualize | bool | False | 各予測の横にクラスアクティベーションヒートマップを保存し、予測されたクラスのスコアを高めたピクセルを表示します。confとclassesを反映するため、classes=[0]の場合はそのクラスのみがマッピングされます。Ultralytics PyTorchモデルでのみ利用できます。 |
augment | bool | False | 予測にテスト時拡張(TTA)を適用します。推論速度は低下する可能性がありますが、検出の頑健性を高められる場合があります。Ultralytics PyTorchモデルでのみ利用できます。 |
agnostic_nms | bool | False | クラス非依存のNon-Maximum Suppression(NMS)を有効にします。同じクラス内だけでなく、異なるクラス間でも重複するボックスを対象に、スコアの低いものを抑制します。クラス間の重複がよく発生するマルチクラス検出で有用です。NMSなし推論(YOLO26またはYOLOv10でnms=False)では、同じ検出が複数のクラスラベルで出力されること(IoU=1.0の重複)を防ぐだけで、異なるボックス間のIoUしきい値に基づく抑制は行いません。 |
classes | list[int] | None | 予測をクラスIDのセットでフィルタリングします。指定したクラスに属する検出のみが返されます。マルチクラス検出タスクで、関連するオブジェクトに対象を絞る場合に便利です。 |
retina_masks | bool | False | 高解像度のセグメンテーションマスクを返します。有効にすると、返されるマスク(masks.data)は元の画像サイズに一致します。無効にすると、推論に使用した画像サイズになります。 |
embed | list[int] | None | 特徴ベクトルまたは埋め込みを抽出するレイヤーを指定します。model.embed(source)では最後から2番目のレイヤーの埋め込みを使用し、model.predict(source, embed=[layer])では特定のレイヤーを選択します。クラスタリングや類似検索などの下流タスクで役立ちます。Ultralytics PyTorchモデルでのみ利用できます。 |
project | str | None | save が有効な場合に、予測出力の保存先となるプロジェクトディレクトリの名前です。相対パスは runs_dir/<task> の下に配置され、絶対パスはそのまま使用されます。 |
name | str | None | 予測実行の名前です。プロジェクトフォルダー内にサブディレクトリを作成し、saveが有効な場合に予測出力を保存するために使用します。 |
stream | bool | False | すべてのフレームを一度にメモリへ読み込む代わりに、Resultsオブジェクトのジェネレーターを返すことで、長時間の動画や大量の画像をメモリ効率よく処理します。 |
verbose | bool | True | 端末に詳細な推論ログを表示するかどうかを制御し、予測処理の進行状況をリアルタイムで確認できるようにします。 |
compile | boolまたはstr | False | PyTorch 2.xのtorch.compileグラフコンパイルをbackend='inductor'で有効にします。True → "default"、False → 無効、または"default"、"reduce-overhead"、"max-autotune-no-cudagraphs"などの文字列モードを指定できます。未対応の場合は警告を表示し、eagerモードにフォールバックします。 |
channels_last | bool | None | ネイティブPyTorch推論でchannels_last(NHWC)メモリ形式を使用します。Noneでは、oneDNNを有効にしたLinuxおよびWindowsのx86 CPU上でPyTorch 1.13以降を使用する場合に自動的に有効になり、Falseでは無効になり、Trueでは対応するx86 CPUまたはCUDAデバイスでの使用を指定します。ARM64、MPS、古いPyTorchバージョン、oneDNN非対応CPU、およびTensorRTやONNXなどのエクスポート形式では変更されません。 |
nms | bool、省略可 | None | デフォルトではNMSを使用したone-to-many推論(NoneまたはTrue)を実行します。利用可能な場合は、Falseを設定してNMSなしのone-to-oneヘッドを使用します。詳細はエンドツーエンド検出ガイドをご覧ください。 |
可視化の引数:
| 引数 | 種類 | デフォルト | 説明 |
|---|---|---|---|
show | bool | False | Trueの場合、注釈付き画像または動画をウィンドウに表示します。開発やテスト中にすぐ視覚的なフィードバックを得るのに便利です。 |
save | bool | False or True | 注釈付き画像または動画をファイルに保存します。ドキュメント作成、追加分析、結果の共有に便利です。CLIで使用する場合のデフォルトはTrue、Pythonで使用する場合はFalseです。 |
save_frames | bool | False | 動画の処理時に、各フレームを画像として保存します。特定のフレームの抽出や、フレームごとの詳細な分析に便利です。 |
save_txt | bool | False | 検出結果を[class] [x_center] [y_center] [width] [height] [confidence]形式のテキストファイルに保存します。他の分析ツールとの連携に便利です。 |
save_conf | bool | False | 保存されるテキストファイルに信頼度スコアを含めます。後処理や分析で利用できる情報が増えます。 |
save_crop | bool | False | 検出したオブジェクトのクロップ画像を保存します。データセットの拡張や分析、特定のオブジェクトに絞ったデータセットの作成に便利です。 |
show_labels | bool | True | 可視化出力で各検出のラベルを表示します。検出されたオブジェクトをすぐに把握できます。 |
show_conf | bool | True | 各検出のラベルとともに信頼度スコアを表示します。各検出に対するモデルの確信度を確認できます。 |
show_boxes | bool | True | 検出されたオブジェクトの周囲にバウンディングボックスを描画します。画像や動画フレーム内のオブジェクトを視覚的に識別し、位置を確認するために不可欠です。 |
line_width | int or None | None | バウンディングボックスの線幅を指定します。Noneの場合、画像サイズに応じて線幅が自動調整されます。見やすさを高めるために表示をカスタマイズできます。 |
推論デバイス#
deviceはすべてのモデルフォーマットでPyTorchのデバイス名を受け取るため、.ptチェックポイントとエクスポート済みモデルのどちらを実行する場合でも、同じ値で同じハードウェアが選択されます。設定しない場合は、利用可能な最適なデバイスが使用されます。各ランタイムはデバイス名をそれぞれのハードウェアに対応付けます。また、検証とベンチマークでも同じ値を使用します。
| 形式 | 未設定 | cpu | 0またはcuda:0 | mps | xpu | npu |
|---|---|---|---|---|---|---|
PyTorch .pt、TorchScript | CUDA GPU、それ以外の場合はCPU | CPU | NVIDIA GPU | Apple GPU | Intel GPU | Huawei Ascend NPU |
| ONNX | CUDA GPU、それ以外の場合はCPU | CPU | NVIDIA GPU(CUDA)、AMD GPU(MIGraphX) | Core ML | - | - |
| TensorRT | NVIDIA GPU | NVIDIA GPU | NVIDIA GPU | - | - | - |
| OpenVINO | OpenVINO AUTO | Intel CPU | - | - | Intel GPU(xpu:1はOpenVINOのGPU.1です) | Intel NPU |
| LiteRT | CPU | CPU | - | - | OpenVINOプラグイン経由のIntel GPU | OpenVINOプラグイン経由のIntel NPU |
| PaddlePaddle | CUDA GPU、それ以外の場合はCPU | CPU | NVIDIA GPU | - | - | - |
-は、そのデバイス用のバックエンドがランタイムにないことを意味します。ONNX、TensorRT、PaddlePaddleは、まずPyTorchでデバイス名を確認するため、PyTorchから認識できないデバイスは拒否し、それ以外の場合はデフォルトのハードウェアで実行します。OpenVINOは、要求されたIntelデバイスが見つからない場合に警告を表示してAUTOにフォールバックし、LiteRT IntelプラグインはCPUにフォールバックします。その他のフォーマットでは、それぞれのハードウェアが選択されます。CoreMLはApple Neural EngineとCPUで実行され、Edge TPUはtpu:0を受け取り、NCNNはVulkan GPU経路でvulkan:0を受け取り、残りのフォーマットは対象デバイスのCPUまたはアクセラレータで実行されます。以前のintel:cpu、intel:gpu、intel:npuという名前は、cpu、xpu、npuの非推奨エイリアスとして引き続き使用できます。
from ultralytics import YOLO
model = YOLO("yolo26n_openvino_model/")
results = model("https://ultralytics.com/images/bus.jpg", device="npu") # Intel NPU画像と動画の形式#
YOLO26は、ultralytics/data/utils.py に記載されているさまざまな画像および動画形式に対応しています。有効な拡張子とpredictコマンドの例については、以下の表を参照してください。
画像#
以下の表に、有効なUltralytics画像形式を示します。
HEIC/HEIF形式には pi-heif が必要です。これは初回使用時に自動でインストールされます。AVIFはPillowでネイティブにサポートされています。
| 画像の拡張子 | predictコマンドの例 | 参照 |
|---|---|---|
.avif | yolo predict source=image.avif | AV1画像ファイル形式 |
.bmp | yolo predict source=image.bmp | Microsoft BMPファイル形式 |
.dng | yolo predict source=image.dng | Adobe DNG |
.heic | yolo predict source=image.heic | 高効率画像形式 |
.heif | yolo predict source=image.heif | 高効率画像形式 |
.jp2 | yolo predict source=image.jp2 | JPEG 2000 |
.jpeg | yolo predict source=image.jpeg | JPEG |
.jpg | yolo predict source=image.jpg | JPEG |
.mpo | yolo predict source=image.mpo | マルチピクチャオブジェクト |
.png | yolo predict source=image.png | ポータブルネットワークグラフィックス |
.tif | yolo predict source=image.tif | タグ付き画像ファイル形式 |
.tiff | yolo predict source=image.tiff | タグ付き画像ファイル形式 |
.webp | yolo predict source=image.webp | WebP |
動画#
以下の表に、有効なUltralytics動画形式を示します。
| 動画の拡張子 | predictコマンドの例 | 参照 |
|---|---|---|
.asf | yolo predict source=video.asf | Advanced Systems Format |
.avi | yolo predict source=video.avi | Audio Video Interleave |
.gif | yolo predict source=video.gif | Graphics Interchange Format |
.m4v | yolo predict source=video.m4v | MPEG-4 Part 14 |
.mkv | yolo predict source=video.mkv | Matroska |
.mov | yolo predict source=video.mov | QuickTimeファイル形式 |
.mp4 | yolo predict source=video.mp4 | MPEG-4 Part 14 - Wikipedia |
.mpeg | yolo predict source=video.mpeg | MPEG-1 Part 2 |
.mpg | yolo predict source=video.mpg | MPEG-1 Part 2 |
.ts | yolo predict source=video.ts | MPEGトランスポートストリーム |
.wmv | yolo predict source=video.wmv | Windows Media Video |
.webm | yolo predict source=video.webm | WebM Project |
Resultsの使用#
すべてのUltralytics predict() 呼び出しは、Results オブジェクトのリストを返します。
from ultralytics import YOLO
# 事前学習済みYOLO26nモデルを読み込む
model = YOLO("yolo26n.pt")
# 画像に対して推論を実行する
results = model("https://ultralytics.com/images/bus.jpg")
results = model(
[
"https://ultralytics.com/images/bus.jpg",
"https://ultralytics.com/images/zidane.jpg",
]
) # バッチ推論Results オブジェクトには、次の属性があります。
| 属性 | 種類 | 説明 |
|---|---|---|
orig_img | np.ndarray | 元画像をNumPy配列で表したものです。 |
orig_shape | tuple | 元画像の形状を(高さ、幅)形式で表したものです。 |
boxes | Boxes, optional | 検出されたバウンディングボックスを含むBoxesオブジェクトです。 |
masks | Masks, optional | 検出されたマスクを含むMasksオブジェクトです。 |
probs | Probs, optional | 分類タスクの各クラスの確率を含むProbsオブジェクトです。 |
keypoints | Keypoints, optional | 各オブジェクトで検出されたキーポイントを含むKeypointsオブジェクトです。 |
obb | OBB, optional | 方向付きバウンディングボックスを含むOBBオブジェクトです。 |
semantic_mask | SemanticMask, optional | ピクセルごとの密なクラスマップを含むSemanticMaskオブジェクトです。 |
depth | DepthMap, optional | ピクセルごとの密な深度マップを含むDepthMapオブジェクトです。 |
speed | dict | 画像ごとの前処理、推論、後処理の速度をミリ秒単位で示す辞書です。 |
names | dict | クラスインデックスとクラス名を対応付ける辞書です。 |
path | str | 画像ファイルへのパスです。 |
save_dir | str, optional | 結果の保存先ディレクトリです。 |
タスク別のResults#
以下のどのフィールドが設定されるかは、モデルのタスクによって異なります。まだタスクを選んでいない場合は、検出、セグメンテーション、セマンティックセグメンテーション、深度推定、分類、ポーズ、OBBを比較するをご覧ください。各予測では、画像またはフレームごとに1つの Results オブジェクトが返されます。上記の共通フィールドは常に利用でき、タスク固有の予測データは以下のフィールドに格納されます。YOLOの座標テンソルと信頼度テンソルは torch.float32 です。確率テンソルは通常 torch.float32 ですが、モデルがFP16で動作する場合(CPU以外でPyTorchまたはTorchScriptモデルを使用する場合の quantize=16、またはFP16入力を使用するONNXモデルの場合)は torch.float16 になります。result.numpy() の後、テンソルは対応するNumPyデータ型のNumPy配列になります。インスタンスマスクは torch.uint8 のバイナリテンソルです。一方、セマンティックマスクでは、クラスIDに対して実用上最小の整数データ型(クラス数に応じて torch.uint8、torch.int16、または torch.int32)が使用されます。
| 属性 | 種類 | 形状 | 説明 |
|---|---|---|---|
result.boxes | Boxes | (N) | 検出ボックスです。 |
result.boxes.data | torch.float32 | (N,6/7) | 生の [x1,y1,x2,y2,conf,cls] と、任意のトラックIDです。 |
result.boxes.xyxy | torch.float32 | (N,4) | xyxy のピクセルボックスです。 |
result.boxes.conf | torch.float32 | (N,) | 信頼度スコアです。 |
result.boxes.cls | torch.float32 | (N,) | クラスIDです。名前を取得するには int にキャストします。 |
Resultsオブジェクトには、次のメソッドがあります。
| メソッド | 戻り値の型 | 説明 |
|---|---|---|
update() | None | ボックス、マスク、確率、obb、キーポイント、セマンティックマスク、深度などの新しいデータでResultsオブジェクトを更新します。 |
cpu() | Results | すべてのテンソルをCPUメモリに移動したResultsオブジェクトのコピーを返します。 |
numpy() | Results | すべてのテンソルをNumPy配列に変換したResultsオブジェクトのコピーを返します。 |
cuda() | Results | すべてのテンソルをGPUメモリに移動したResultsオブジェクトのコピーを返します。 |
to() | Results | テンソルを指定したデバイスとdtypeに移動したResultsオブジェクトのコピーを返します。 |
new() | Results | 同じ画像、パス、names、speed属性を持つ新しいResultsオブジェクトを作成します。 |
plot() | np.ndarray | 入力BGR画像に検出結果をプロットし、注釈付き画像を返します。 |
show() | None | 推論結果を注釈として追加した画像を表示します。 |
save() | str | 推論結果を注釈として追加した画像をファイルに保存し、ファイル名を返します。 |
verbose() | str | 各タスクのログ文字列を返し、検出と分類の結果を詳しく示します。 |
save_txt() | str | 検出結果をテキストファイルに保存し、保存したファイルのパスを返します。 |
save_crop() | None | 検出画像のクロップを指定したディレクトリに保存します。 |
summary() | List[Dict[str, Any]] | 推論結果を、オプションで正規化した要約辞書に変換します。 |
to_df() | DataFrame | 検出結果をPolars DataFrameに変換します。 |
to_csv() | str | 検出結果をCSV形式に変換します。 |
to_json() | str | 検出結果をJSON形式に変換します。 |
詳細については、Resultsクラスのドキュメントを参照してください。
ボックス#
Boxesオブジェクトを使用して、バウンディングボックスのインデックス指定、操作、形式変換を行えます。
from ultralytics import YOLO
# 事前学習済みYOLO26nモデルを読み込む
model = YOLO("yolo26n.pt")
# 画像に対して推論を実行する
results = model("https://ultralytics.com/images/bus.jpg") # 結果リスト
# 結果を表示
for r in results:
print(r.boxes) # 検出バウンディングボックスを含むBoxesオブジェクトを出力Boxesクラスのメソッドとプロパティについて、名前、型、説明を含む表を以下に示します。
| 名前 | 種類 | 説明 |
|---|---|---|
cpu() | メソッド | オブジェクトをCPUメモリに移動します。 |
numpy() | メソッド | オブジェクトをNumPy配列に変換します。 |
cuda() | メソッド | オブジェクトをCUDAメモリに移動します。 |
to() | メソッド | オブジェクトを指定したデバイスに移動します。 |
xyxy | プロパティ(torch.Tensor) | ボックスをxyxy形式で返します。 |
conf | プロパティ(torch.Tensor) | ボックスの信頼度を返します。 |
cls | プロパティ(torch.Tensor) | ボックスのクラス値を返します。 |
id | プロパティ(torch.Tensor) | ボックスのトラックIDを返します(利用可能な場合)。 |
xywh | プロパティ(torch.Tensor) | ボックスをxywh形式で返します。 |
xyxyn | プロパティ(torch.Tensor) | 元の画像サイズで正規化したボックスをxyxy形式で返します。 |
xywhn | プロパティ(torch.Tensor) | 元の画像サイズで正規化したボックスをxywh形式で返します。 |
詳細については、Boxesクラスのドキュメントを参照してください。
マスク#
Masksオブジェクトを使用して、マスクのインデックス指定、操作、セグメントへの変換を行えます。
from ultralytics import YOLO
# 事前学習済みのYOLO26n-segセグメンテーションモデルを読み込む
model = YOLO("yolo26n-seg.pt")
# 画像に対して推論を実行する
results = model("https://ultralytics.com/images/bus.jpg") # 結果リスト
# 結果を表示
for r in results:
print(r.masks) # 検出されたインスタンスマスクを含むMasksオブジェクトを出力Masksクラスのメソッドとプロパティについて、名前、型、説明を含む表を以下に示します。
| 名前 | 種類 | 説明 |
|---|---|---|
data | プロパティ(torch.Tensor) | torch.uint8は、形状が(N,H,W)で、値が0または1のバイナリマスクテンソルです。 |
cpu() | メソッド | マスクテンソルをCPUメモリ上で返します。 |
numpy() | メソッド | マスクテンソルをNumPy配列として返します。 |
cuda() | メソッド | マスクテンソルをGPUメモリ上で返します。 |
to() | メソッド | 指定したデバイスとdtypeのマスクテンソルを返します。 |
xyn | プロパティ(list[np.ndarray]) | 正規化されたマスクポリゴンのリストです。 |
xy | プロパティ(list[np.ndarray]) | ピクセル座標のマスクポリゴンのリストです。 |
詳細については、Masksクラスのドキュメントを参照してください。
SemanticMask#
SemanticMaskは、セマンティックセグメンテーションの結果を表す単一の高密度クラスマップを格納します。Masksとは異なり、オブジェクトごとのバイナリマスクは含まず、ポリゴン用のヘルパーも提供しません。
from ultralytics import YOLO
# 事前学習済みのYOLO26n-semセマンティックモデルを読み込む
model = YOLO("yolo26n-sem.pt")
# 画像に対して推論を実行する
results = model("https://ultralytics.com/images/bus.jpg") # 結果リスト
# 結果を表示
for r in results:
print(r.semantic_mask.data) # H x WのクラスIDマップを出力| 名前 | 種類 | 説明 |
|---|---|---|
data | プロパティ(torch.Tensor) | 形状が(H,W)のクラスIDマップです。dtypeは、クラス数に応じてtorch.uint8、torch.int16、またはtorch.int32になります。 |
shape | プロパティ(tuple) | クラスマップの形状です。通常はresult.orig_shapeと一致します。 |
cpu() | メソッド | セマンティックマスクテンソルをCPUメモリ上で返します。 |
numpy() | メソッド | セマンティックマスクテンソルをNumPy配列として返します。 |
cuda() | メソッド | セマンティックマスクテンソルをGPUメモリ上で返します。 |
to() | メソッド | 指定したデバイスとdtypeのセマンティックマスクテンソルを返します。 |
キーポイント#
Keypointsオブジェクトを使用して、座標のインデックス指定、操作、正規化を行えます。
from ultralytics import YOLO
# 事前学習済みのYOLO26n-poseポーズモデルを読み込む
model = YOLO("yolo26n-pose.pt")
# 画像に対して推論を実行する
results = model("https://ultralytics.com/images/bus.jpg") # 結果リスト
# 結果を表示
for r in results:
print(r.keypoints) # 検出されたキーポイントを含むKeypointsオブジェクトを出力Keypointsクラスのメソッドとプロパティについて、名前、型、説明を含む表を以下に示します。
| 名前 | 種類 | 説明 |
|---|---|---|
cpu() | メソッド | キーポイントテンソルをCPUメモリ上で返します。 |
numpy() | メソッド | キーポイントテンソルをNumPy配列として返します。 |
cuda() | メソッド | キーポイントテンソルをGPUメモリ上で返します。 |
to() | メソッド | 指定したデバイスとdtypeのキーポイントテンソルを返します。 |
xyn | プロパティ(torch.Tensor) | 形状が(N,K,2)の正規化されたキーポイント座標です。 |
xy | プロパティ(torch.Tensor) | 形状が(N,K,2)のピクセル単位のキーポイント座標です。 |
conf | プロパティ(torch.Tensor) | キーポイントの信頼度を返します。利用できない場合はNoneを返します。 |
詳細については、Keypointsクラスのドキュメントを参照してください。
確率#
Probsオブジェクトを使用して、top1とtop5の分類インデックスおよびスコアを取得できます。
from ultralytics import YOLO
# 事前学習済みのYOLO26n-cls分類モデルを読み込む
model = YOLO("yolo26n-cls.pt")
# 画像に対して推論を実行する
results = model("https://ultralytics.com/images/bus.jpg") # 結果リスト
# 結果を表示
for r in results:
print(r.probs) # 検出されたクラス確率を含むProbsオブジェクトを出力Probsクラスのメソッドとプロパティをまとめた表を以下に示します。
| 名前 | 種類 | 説明 |
|---|---|---|
cpu() | メソッド | probsテンソルのコピーをCPUメモリ上に返します。 |
numpy() | メソッド | probsテンソルのコピーをNumPy配列として返します。 |
cuda() | メソッド | probsテンソルのコピーをGPUメモリ上に返します。 |
to() | メソッド | 指定したデバイスとdtypeでprobsテンソルのコピーを返します。 |
top1 | プロパティ(int) | トップ1クラスのインデックス。 |
top5 | プロパティ(list[int]) | トップ5クラスのインデックス。 |
top1conf | プロパティ(torch.Tensor) | トップ1クラスの信頼度。 |
top5conf | プロパティ(torch.Tensor) | トップ5クラスの信頼度。 |
詳細については、Probsクラスのドキュメントを参照してください。
OBB#
OBBオブジェクトを使用して、方向付きバウンディングボックスのインデックス付け、操作、さまざまな形式への変換を行えます。
from ultralytics import YOLO
# 事前学習済みYOLO26nモデルを読み込む
model = YOLO("yolo26n-obb.pt")
# 画像に対して推論を実行する
results = model("https://ultralytics.com/images/boats.jpg") # 結果リスト
# 結果を表示
for r in results:
print(r.obb) # 方向付き検出バウンディングボックスを含むOBBオブジェクトを出力するOBBクラスのメソッドとプロパティについて、名前、型、説明を含む表を以下に示します。
| 名前 | 種類 | 説明 |
|---|---|---|
cpu() | メソッド | オブジェクトをCPUメモリに移動します。 |
numpy() | メソッド | オブジェクトをNumPy配列に変換します。 |
cuda() | メソッド | オブジェクトをCUDAメモリに移動します。 |
to() | メソッド | オブジェクトを指定したデバイスに移動します。 |
conf | プロパティ(torch.Tensor) | ボックスの信頼度を返します。 |
cls | プロパティ(torch.Tensor) | ボックスのクラス値を返します。 |
id | プロパティ(torch.Tensor) | ボックスのトラックIDを返します(利用可能な場合)。 |
xyxy | プロパティ(torch.Tensor) | 水平バウンディングボックスをxyxy形式で返します。 |
xywhr | プロパティ(torch.Tensor) | 回転バウンディングボックスをxywhr形式で返します。 |
xyxyxyxy | プロパティ(torch.Tensor) | 回転バウンディングボックスをxyxyxyxy形式で返します。 |
xyxyxyxyn | プロパティ(torch.Tensor) | 画像サイズで正規化した回転バウンディングボックスをxyxyxyxy形式で返します。 |
詳細については、OBBクラスのドキュメントを参照してください。
結果のプロット#
Resultsオブジェクトのplot()メソッドを使用すると、検出されたオブジェクト(バウンディングボックス、マスク、キーポイント、確率など)を元の画像に重ねて、予測結果を可視化できます。このメソッドは注釈付き画像をNumPy配列として返すため、簡単に表示または保存できます。
from PIL import Image
from ultralytics import YOLO
# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")
# Run inference on 'bus.jpg'
results = model(["https://ultralytics.com/images/bus.jpg", "https://ultralytics.com/images/zidane.jpg"]) # results list
# Visualize the results
for i, r in enumerate(results):
# Plot results image
im_bgr = r.plot() # BGR-order numpy array
im_rgb = Image.fromarray(im_bgr[..., ::-1]) # RGB-order PIL image
# Show results to screen (in supported environments)
r.show()
# Save results to disk
r.save(filename=f"results{i}.jpg")plot()メソッドのパラメーター#
plot()メソッドでは、出力をカスタマイズするためのさまざまな引数を使用できます。
| 引数 | 種類 | 説明 | デフォルト |
|---|---|---|---|
conf | bool | 検出の信頼度スコアを含めます。 | True |
line_width | float | バウンディングボックスの線幅です。Noneの場合、画像サイズに応じて拡大縮小されます。 | None |
font_size | float | テキストのフォントサイズです。Noneの場合、画像サイズに応じて拡大縮小されます。 | None |
font | str | テキスト注釈に使用するフォント名です。 | 'Arial.ttf' |
pil | bool | 画像をPIL Imageオブジェクトとして返します。 | False |
img | np.ndarray | torch.Tensor | 代替画像です。テンソルは連続したHWC BGR uint8形式である必要があります。 | None |
kpt_radius | int | 描画するキーポイントの半径です。 | 5 |
kpt_line | bool | キーポイントを線で接続します。 | True |
labels | bool | 注釈にクラスラベルを含めます。 | True |
boxes | bool | 画像にバウンディングボックスを重ねます。 | True |
masks | bool | 画像にマスクを重ねます。 | True |
probs | bool | 分類確率を含めます。 | True |
show | bool | デフォルトの画像ビューアーを使用して、注釈付き画像を直接表示します。 | False |
save | bool | filenameで指定したファイルに注釈付き画像を保存します。 | False |
filename | str | saveがTrueの場合に注釈付き画像を保存するファイルのパスと名前です。 | None |
color_mode | str | 「instance」や「class」などのカラーモードを指定します。 | 'class' |
txt_color | tuple[int, int, int] | 分類ラベルのテキスト色(BGR)です。 | (255, 255, 255) |
スレッドセーフな推論#
複数のYOLOモデルを異なるスレッドで並列実行する場合、推論中のスレッドセーフ性を確保することが重要です。スレッドセーフな推論では、各スレッドの予測が分離され、互いに干渉しないことが保証されます。これにより、競合状態を回避し、一貫性と信頼性のある出力を確保できます。
マルチスレッドアプリケーションでYOLOモデルを使用する場合は、競合を防ぐため、スレッドごとに個別のモデルオブジェクトをインスタンス化するか、スレッドローカルストレージを使用することが重要です。
スレッドセーフな推論を行うには、各スレッド内でモデルを1つインスタンス化します。
from threading import Thread
from ultralytics import YOLO
def thread_safe_predict(model, image_path):
"""Performs thread-safe prediction on an image using a locally instantiated YOLO model."""
model = YOLO(model)
results = model.predict(image_path)
# 結果を処理する
# それぞれが独自のモデルインスタンスを持つスレッドを開始する
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image2.jpg")).start()ストリーミングソースのforループ#
OpenCV(cv2)とYOLOを使用して、ビデオフレームに推論を実行するPythonスクリプトの例です。このスクリプトでは、必要なパッケージ(opencv-pythonおよびultralytics)がすでにインストールされていることを前提としています。
import cv2
from ultralytics import YOLO
# YOLOモデルを読み込む
model = YOLO("yolo26n.pt")
# ビデオファイルを開く
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)
# ビデオフレームをループ処理する
while cap.isOpened():
# ビデオからフレームを読み込む
success, frame = cap.read()
if success:
# フレームにYOLO推論を実行する
results = model(frame)
# フレーム上に結果を可視化する
annotated_frame = results[0].plot()
# 注釈付きフレームを表示する
cv2.imshow("YOLO Inference", annotated_frame)
# 'q'が押された場合にループを終了する
if cv2.waitKey(1) & 0xFF == ord("q"):
break
else:
# ビデオの最後に到達した場合にループを終了する
break
# ビデオキャプチャオブジェクトを解放し、表示ウィンドウを閉じる
cap.release()
cv2.destroyAllWindows()このスクリプトはビデオの各フレームに予測を実行し、結果を可視化してウィンドウに表示します。「q」を押すとループを終了できます。
次のステップ#
事前学習済みモデルの次の段階に進む準備はできていますか?タスクが問題に適しているか確認し、データセットガイドを参考に独自のデータを形式化してから、そのデータで学習してください。
よくある質問#
Ultralytics YOLOは、リアルタイムの物体検出、インスタンスセグメンテーション、セマンティックセグメンテーション、深度推定、分類、姿勢推定、方向付きバウンディングボックス(OBB)検出に対応する、最先端モデルのファミリーです。予測モードでは、画像、動画、ライブストリームなどのデータソースに対して、高速な推論を実行できます。また、バッチ処理とストリーミングにも対応しています。
Ultralytics YOLOは、個々の画像、ビデオ、ディレクトリ、URL、ストリームなど、幅広いデータソースを処理できます。
model.predict()呼び出しでデータソースを指定できます。たとえば、ローカル画像には'image.jpg'を、URLには'https://ultralytics.com/images/bus.jpg'を使用します。ドキュメントの推論ソースでは、さまざまなソースの詳細な例をご覧いただけます。推論速度を最適化し、メモリを効率的に管理するには、予測器の呼び出しメソッドで
stream=Trueを設定してストリーミングモードを使用できます。ストリーミングモードでは、すべてのフレームをメモリに読み込む代わりに、メモリ効率の高いResultsオブジェクトのジェネレーターが生成されます。長いビデオや大規模なデータセットを処理する場合に特に便利です。ストリーミングモードの詳細をご覧ください。YOLOの
model.predict()メソッドでは、conf、iou、imgsz、deviceなど、さまざまな引数を使用できます。これらの引数を使って推論プロセスをカスタマイズし、信頼度のしきい値、画像サイズ、計算に使用するデバイスなどのパラメーターを設定できます。各引数の詳しい説明は、推論引数のセクションをご覧ください。model.embed(source)を使用すると、最後から2番目のレイヤーから特徴埋め込みを抽出できます。または、特定のレイヤーを選択するには、embed=[layer_index]をmodel.predict()に渡します。from ultralytics import YOLO model = YOLO("yolo26n.pt") source = "https://ultralytics.com/images/bus.jpg" results = model.predict(source) # 結果オブジェクト embeddings = model.embed(source) # torch.Tensor埋め込みのリストYOLOで推論を実行すると、
Resultsオブジェクトに注釈付き画像を表示および保存するメソッドが含まれます。result.show()やresult.save(filename="result.jpg")などのメソッドを使用して、結果を可視化して保存できます。ファイル名のパスに存在しない親ディレクトリは自動的に作成されます(例:result.save("path/to/result.jpg"))。これらのメソッドの一覧については、結果の操作のセクションをご覧ください。
コメント629
質問したり、結果を共有したり、ほかの人をサポートしたりできます。
Tigores
你好,我想问一下为什么我在推理相同的图像时,设置不同的imgsz参数,会有不同的结果。在一张图像上,有大船、小船、人。imgsz设置的值有640(默认)、1280、1980。640只能检测到大船;1280会检测到大船和小船,并且大船的置信度更高;1980还能检测到人。我很疑惑,模型的输入尺寸不是在训练的时候就已经固定了吗,这是否意味着推理的图像预处理阶段,不管我如何调整imgsz参数,模型都会将输入图像采样到640。但是现在出现的不同的结果,是为什么呢?下面是我的代码: from ultralytics import YOLO model = YOLO("/data/dxh/ultralytics/weight/yolov8s.pt")
results = model("/data/dxh/ultralytics/datasets/test/invade_ship_cls/invade_result", imgsz=1280, save=True)1
Glenn JocherUltralytics@Tigores 您好!YOLO模型在推理时会自动将输入图像缩放到您指定的imgsz参数值(而非固定为训练尺寸),更大的分辨率能保留更多细节从而提升小目标检测能力。具体原理可参考Predict模式文档中的图像尺寸与精度关系说明,这是预期行为而非异常现象。
LwpZoe
Hello, I would like to ask, my task is instance segmentation. At present, I get the predicted result is the original image superimposed label image, but the result I want is just the RGB label image, no need to superimpose the original image. Where do I need to make changes to make the result a segmented label image?
1
Glenn JocherUltralytics(編集済み)@LwpZoe to obtain only the RGB label image without the original image overlay, you can disable the overlay during visualization. Use the
plot()method withboxes=Falseandmasks=Trueto only display the segmentation masks. Alternatively, you can directly accessresult.masks.datafor raw mask data and process it as needed. Refer to the Results section for more details.LwpZoe
Found plot () in yolo-segment-main/ultralytics/engine/results.py, modified content: Def plot ( Self, Conf = True, line_width = None, font_size = None, Font = "Arial.ttf", Pil = False, Img = None, im_gpu = None, kpt_radius = 5, kpt_line = False, Labels = False, Boxes = False, Masks = True, Probs = True, Show = True, Save = True, Filename = 'result', color_mode = "class", ): Make predictions using the command line: Yolo segment predict model = runs/segment/train/weights/best.pt source=yolo-seg-main/datasets/test The result is still the original image overlay mask and box, why? Does changing plot () require retraining to get best.pt in order to predict?
Glenn JocherUltralyticsTo display only the segmentation mask without overlays, modify the
plot()function parameters by settingboxes=False,labels=False, and ensuringmasks=True. You don't need retraining to adjust visualization settings, as the weights remain unaffected. For further details, refer to the Results.plot() documentation.
UserHello, when I run the predict script, I predict a large amount of image data (about more than 20,000 test images). At this time, the model's predict will get stuck, and I don't generate the image of the prediction box. How can I solve this bug?
1
Paula DerrengerUltralytics@Stephen-Hao it sounds like you might be running into memory issues when processing a large number of images. To handle large datasets more efficiently, consider using the
stream=Trueargument in yourmodel.predict()call. This will create a memory-efficient generator of results, reducing the likelihood of your system getting stuck. Additionally, ensure you are using the latest version of the Ultralytics package to benefit from any recent optimizations and bug fixes. If the issue persists, please provide more details about your environment and any error messages you encounter.
UserYes, Thank you a lot.
Paula DerrengerUltralytics@Stephen-Hao you're welcome! If you're experiencing issues with the model getting stuck while predicting a large number of images, try using the
stream=Trueargument in yourmodel.predict()call. This will help manage memory more efficiently by processing images one at a time instead of loading all at once. Also, ensure you're using the latest version of the Ultralytics package. If the problem persists, please provide more details about your setup and any error messages you encounter.
Johanna-Jones
Hey, Is there a way to get the MAP precision, IOU and other metrics for the test images you might give the model?
I have images and the ground truth for the test images but not sure how to get the same metrics for the PREDICT mode
Thank you!
1Johanna-Jones
For clarification my pipeline is currently train> valid with
valparameter set to false. I then pass one image at a time to the Yolov8 model in the PREDICT mode
Paula DerrengerUltralyticsHey there!
For evaluating your model with metrics like mAP, precision, and IOU on your test images, you should use the
Valmode rather than thePredictmode. TheValmode allows you to validate your model on a dataset and provides comprehensive metrics, including the ones you're interested in. Here's an example on how to do it:from ultralytics import YOLO # Assuming 'coco128.yaml' is your dataset configuration file that includes your test data path # and that 'your_model.pt' is the trained model you want to evaluate model = YOLO('path/to/your_model.pt') # Validate the model, this will automatically calculate mAP, IOU, and other metrics results = model.val(data='path/to/your_dataset_config.yaml')Remember to adjust
'path/to/your_model.pt'and'path/to/your_dataset_config.yaml'to the actual paths of your model and dataset configuration file.In your YAML dataset configuration file, make sure to correctly specify the path to your test images and annotations. This way, YOLOv8 will know how to find your test data and corresponding ground truth for evaluation.
If you have any more questions, feel free to ask. Good luck with your model evaluation! 🚀
GUPABE10
how to ignore printing results after inference: 0: 384x640 10 persons, 1 sports ball, 4080.4ms Speed: 12.3ms preprocess, 4080.4ms inference, 1.7ms postprocess per image at shape (1, 3, 384, 640)
1
Glenn JocherUltralyticsTo disable printing inference results after running predictions, you can use the
verbose=Falseargument in yourpredict()function. This will prevent the printout of inference times and detected objects. Here's a quick example on how to do it:from ultralytics import YOLO # Load your YOLOv8 model model = YOLO('yolov8n.pt') # Run inference with verbose=False results = model.predict('path/to/your/image.jpg', verbose=False)This should keep your console output clean while still performing inference. 😊
GUPABE10
Is it the same if I use:
results = model('path/to/your/image.jpg')
just as mentioned in the example in this tutorial.
Glenn JocherUltralytics@GUPABE10 hi there!
Yes, using
results = model('path/to/your/image.jpg')is perfectly fine and aligns with the examples provided in the tutorial. This command will run inference on the specified image and return the results as a list ofResultsobjects.If you want to avoid printing the detailed inference results (like the number of detected objects and processing times), you can use the
verbose=Falseargument:from ultralytics import YOLO # Load a pretrained YOLOv8n model model = YOLO("yolov8n.pt") # Run inference on an image without printing detailed results results = model.predict('path/to/your/image.jpg', verbose=False)This will keep your console output clean while still performing the inference. If you have any more questions or need further assistance, feel free to ask! 😊
GUPABE10
What is the difference between model.predict() and model()?
Glenn JocherUltralyticsHi there!
Great question! The difference between
model.predict()andmodel()lies in their usage and flexibility:-
model.predict():- This method is explicitly designed for running predictions and allows you to pass various arguments to customize the inference process.
- You can specify parameters like
save,imgsz,conf,device, and more to control the behavior of the prediction. - Example:
from ultralytics import YOLO # Load a pretrained YOLOv8n model model = YOLO("yolov8n.pt") # Run inference with custom arguments results = model.predict("path/to/image.jpg", save=True, imgsz=320, conf=0.5)
-
model():- This is a shorthand method that calls the
predict()function internally with default settings. - It is useful for quick predictions without needing to specify additional parameters.
- Example:
from ultralytics import YOLO # Load a pretrained YOLOv8n model model = YOLO("yolov8n.pt") # Run inference with default settings results = model("path/to/image.jpg")
- This is a shorthand method that calls the
Both methods will return a list of
Resultsobjects, which you can then process as needed. If you need more control over the prediction process,model.predict()is the way to go. For quick and straightforward predictions,model()is convenient.Feel free to check out the Ultralytics documentation on prediction for more details and examples.
Happy coding! 😊
-
amani784
Hello @glenn-jocher, i have question, my inputs are videos, if i use vid-stride , can i use imgsz with it ?
Glenn JocherUltralyticsYes—
vid_stride(frame skipping) andimgsz(inference resize) are independent, so you can use them together on video sources;imgszwill be applied to the frames that are actually processed (see the Predict mode inference arguments).yolo predict model=yolo26n.pt source=video.mp4 vid_stride=2 imgsz=640from ultralytics import YOLO model = YOLO("yolo26n.pt") for r in model.predict("video.mp4", vid_stride=2, imgsz=640, stream=True): pass1amani784
Thank you for your help. I have another question: if I don’t define imgsz in predict, will it resize the image to 640 by default? I have multiple inputs with different resolutions, so I can’t specify a single value for imgsz in .predict or even during ONNX export, because sometimes the input resolution is larger than imgsz.
Glenn JocherUltralyticsYes—if you don’t pass
imgsztopredict(), it uses the defaultimgsz=640and will letterbox/resize each frame/image to that inference size (so larger inputs are downscaled, smaller are upscaled); for mixed-resolution sources you can either leave the default or set a largerimgszfor more detail (GPU memory permitting) as described in the predict settings defaults.If you need an ONNX that can accept varying input shapes at runtime, export with dynamic shapes enabled (then your runtime can feed different H×W sizes):
yolo export model=yolo26n.pt format=onnx dynamic=Truefrom ultralytics import YOLO model = YOLO("yolo26n.pt") model.export(format="onnx", dynamic=True)Feel free to drop the exact input resolutions (and whether this is video-only) here in the discussion and we can suggest a good
imgszstrategy for your case.1amani784
Thank you so much ,but for tensorRT export , the model can't accept varying input shapes and i was obliged to put imgsz or my videos have different resolutions and i can't put one imgsz value that can fit all the resolutions. Is there any other solution?
Glenn JocherUltralyticsYes—TensorRT doesn’t have to be fixed-shape: export your
.enginewithdynamic=Trueso the runtime can accept varying input shapes (you can then chooseimgszper run/video), see the Export mode docs and the TensorRT integration guide.yolo export model=yolo26n.pt format=engine dynamic=TrueIf you need peak throughput and your resolutions vary a lot, the usual workaround is exporting 2–3 fixed engines at common
imgszvalues and selecting the closest one at runtime.1
Asshok1
Hey @glenn-jocher, I’m trying to integrate a TensorRT-optimized YOLO model (.engine) with SAHI (Slicing Aided Hyper Inference) for efficient large-image inference, but I’m facing difficulties making them work together correctly as .engine is not accepted in sahi, can you help in providing the complete code for integrating tensorRT with sahi.
Glenn JocherUltralyticsSAHI’s built-in Ultralytics integration (
model_type="ultralytics") currently expects PyTorch weights like*.pt, so a TensorRT*.enginefile won’t load through SAHI as-is; the supported path is to use SAHI with*.ptper the SAHI tiled inference guide, or run the TensorRT engine directly with Ultralytics per the TensorRT export/inference guide. If you specifically need SAHI slicing + a*.engine, you’ll need a custom SAHIDetectionModeladapter around Ultralytics’ TensorRT predictor (best tracked upstream in the SAHI repository); please paste your Ultralytics/SAHI versions and a minimal repro here in the discussion so we can advise on the cleanest adapter approach.# SAHI (supported): Ultralytics *.pt + slicing from sahi import AutoDetectionModel from sahi.predict import get_sliced_prediction detection_model = AutoDetectionModel.from_pretrained( model_type="ultralytics", model_path="best.pt", confidence_threshold=0.25, device="cuda:0", ) result = get_sliced_prediction( "large.jpg", detection_model, slice_height=640, slice_width=640, overlap_height_ratio=0.2, overlap_width_ratio=0.2, )# TensorRT (supported): Ultralytics *.engine inference (no SAHI wrapper) from ultralytics import YOLO model = YOLO("best.engine") results = model.predict("large.jpg", device=0, imgsz=640)
hanchaoyuan
hello! I used the YOLO11-pose model to estimate the key points of people in the automotive production workshop. However, the model often identified vehicles, hoists and other equipment as humans and calculated the key points, resulting in a relatively high false alarm rate. My question is: How can we prevent the model from identifying other objects and reduce the false alarm rate?
Glenn JocherUltralyticsFor workshop false positives with pose models, the quickest lever is raising the prediction threshold (and optionally increasing
imgszfor better person discrimination), but the most reliable fix is fine-tuning on your own workshop data with “hard negative” images (frames with vehicles/hoists but no people) so the model learns your background; see the inference args in the predict mode docs.yolo pose predict model=yolo11n-pose.pt source=path/to/video.mp4 conf=0.6 imgsz=960If you paste your exact command, plus a couple representative frames (people + false positives) here in the discussion, we can suggest tighter settings or a training setup (and for new work, try a YOLO26 pose checkpoint as it’s generally stronger out of the box).
d5423197
Hi there,
If no boxes/masks detected by the model, what will be the output of model inference. (results = model(["image1.jpg", "image2.jpg"]) #)
I want to deal with the edge case.
max-dev-14
How to predict and show or save prediction YOLO (custom model) for video fragment?
