はじめる

クイックスタートガイド:NVIDIA JetsonでUltralytics YOLO26を使う

このガイドでは、NVIDIA JetsonデバイスへのUltralytics YOLO26のデプロイ手順を説明し、小型で電力効率に優れたこれらのデバイスでYOLO26が実現できる性能を示すベンチマークも掲載しています。

新製品への対応

最大2070 FP4 TFLOPSのAI演算性能と128 GBのメモリを備え、電力を40 Wから130 Wの範囲で設定できる最新のNVIDIA Jetson AGX Thor Developer Kitに合わせて、このガイドを更新しました。NVIDIA Jetson AGX Orinと比べてAI演算性能は7.5倍以上、最も広く使われているAIモデルの実行時のエネルギー効率は3.5倍向上します。



視聴する: NVIDIA JetsonデバイスでUltralytics YOLO26を活用して、より高速な推論を実現しましょう 🚀
NVIDIA Jetson Ecosystem
注

このガイドは、最新の安定版JetPack 7.2を実行するNVIDIA Jetson AGX Thor Developer Kit(Jetson T5000)およびNVIDIA Jetson AGX Orin Developer Kit(64GB)、JetPackリリースのJP6.1を実行するNVIDIA Jetson Orin Nano Super Developer Kit、JetPackリリースのJP6.0/JetPackリリースのJP5.1.3を実行する、NVIDIA Jetson Orin NX 16GBをベースとしたSeeed Studio reComputer J4012、およびJetPackリリースのJP4.6.1を実行する、NVIDIA Jetson Nano 4GBをベースとしたSeeed Studio reComputer J1020 v2でテスト済みです。最新および旧世代のデバイスを含む、すべてのNVIDIA Jetsonハードウェア製品で動作することが期待されます。

NVIDIA Jetsonとは何ですか?#

NVIDIA Jetsonは、アクセラレーションされたAI(人工知能)演算をエッジデバイスにもたらすために設計された組み込みコンピューティングボードのシリーズです。小型で高性能なこれらのデバイスはNVIDIAのGPUアーキテクチャを採用しており、クラウドコンピューティングのリソースに頼らず、デバイス上で複雑なAIアルゴリズムやディープラーニングモデルを直接実行できます。Jetsonボードは、ロボティクス、自動運転車、産業オートメーションなど、AI推論をローカルで低レイテンシかつ高効率に実行する必要がある用途でよく使用されます。また、ARM64アーキテクチャを採用し、従来のGPUコンピューティングデバイスよりも低い消費電力で動作します。

NVIDIA Jetsonシリーズの比較#

NVIDIA Jetson AGX Thorは、NVIDIA Blackwellアーキテクチャを採用したNVIDIA Jetsonファミリーの最新製品で、従来世代よりも大幅に高いAI性能を実現します。以下の表では、エコシステム内のJetsonデバイスをいくつか比較しています。

Jetson AGX Thor(T5000)Jetson AGX Orin 64GBJetson Orin NX 16GBJetson Orin Nano SuperJetson AGX XavierJetson Xavier NXJetson Nano
AI性能2070 TFLOPS275 TOPS100 TOPS67 TOPS32 TOPS21 TOPS472 GFLOPS
GPU2560コアのNVIDIA BlackwellアーキテクチャGPU、96基のTensor Core2048コアのNVIDIA AmpereアーキテクチャGPU、64基のTensor Core1024コアのNVIDIA AmpereアーキテクチャGPU、32基のTensor Core1024コアのNVIDIA AmpereアーキテクチャGPU、32基のTensor Core512コアのNVIDIA VoltaアーキテクチャGPU、64基のTensor Core384コアのNVIDIA Volta™アーキテクチャGPU、48基のTensor Core128コアのNVIDIA Maxwell™アーキテクチャGPU
GPU最大周波数1.57 GHz1.3 GHz918 MHz1020 MHz1377 MHz1100 MHz921MHz
CPU14コアArm® Neoverse®-V3AE 64ビットCPU、1MB L2 + 16MB L312コアNVIDIA Arm® Cortex A78AE v8.2 64ビットCPU、3MB L2 + 6MB L38コアNVIDIA Arm® Cortex A78AE v8.2 64ビットCPU、2MB L2 + 4MB L36コア Arm® Cortex®-A78AE v8.2 64ビット CPU、L2 1.5MB + L3 4MB8コア NVIDIA Carmel Arm®v8.2 64ビット CPU、L2 8MB + L3 4MB6コア NVIDIA Carmel Arm®v8.2 64ビット CPU、L2 6MB + L3 4MBクアッドコア Arm® Cortex®-A57 MPCore プロセッサ
CPU最大周波数2.6 GHz2.2 GHz2.0 GHz1.7 GHz2.2 GHz1.9 GHz1.43GHz
メモリ128GB 256ビット LPDDR5X 273GB/s64GB 256ビット LPDDR5 204.8GB/s16GB 128ビット LPDDR5 102.4GB/s8GB 128ビット LPDDR5 102 GB/s32GB 256ビット LPDDR4x 136.5GB/s8GB 128ビット LPDDR4x 59.7GB/s4GB 64ビット LPDDR4 25.6GB/s

NVIDIA JetPackとは何ですか?#

NVIDIA JetPack SDKはJetsonモジュールを動かし、エンドツーエンドのアクセラレーション対応AIアプリケーションを構築するための包括的な開発環境を提供します。JetPackには、ブートローダー、Linuxカーネル、Ubuntuデスクトップ環境を含むJetson Linuxと、GPUコンピューティング、マルチメディア、グラフィックス、コンピュータービジョンを高速化するライブラリ一式が含まれます。また、ホストコンピューターと開発キットの両方に対応するサンプル、ドキュメント、開発者ツールに加え、ストリーミング動画分析向けのDeepStream、ロボティクス向けのIsaac、対話型AI向けのRivaなどの上位SDKもサポートしています。

NVIDIA JetsonにJetPackを書き込む#

NVIDIA Jetsonデバイスを入手した後の最初の手順は、NVIDIA JetPackをデバイスに書き込むことです。NVIDIA Jetsonデバイスを書き込む方法はいくつかあります。

  1. 公式Jetson AGX Thor、AGX Orin、またはOrin Nano Developer KitでJetPack 7.2を使用する場合は、統合Jetson ISOをダウンロードしてUSBフラッシュドライブに書き込み、AGX Thor、AGX Orin、またはOrin Nanoのデバイス別クイックスタートに従ってください。JetPack 7.2以降、Orin Nanoではダウンロード可能なSDカードイメージを使用しなくなりました。ISOを使用したUSBインストールにより、Jetson LinuxがデバイスのmicroSDカードまたはNVMe SSDにインストールされます。
  2. Jetson Orin Nano Developer KitでJetPack 6を意図的に使用する場合は、NVIDIAのJetPack 6.xアップデートおよびSDカードの手順に従ってください。
  3. その他のNVIDIA Development Kitをお持ちの場合は、SDK Managerを使用してデバイスにJetPackを書き込むことができます。
  4. Seeed Studio reComputer J4012をお持ちの場合は、付属のSSDにJetPackを書き込むことができます。また、Seeed Studio reComputer J1020 v2をお持ちの場合は、eMMC/ SSDにJetPackを書き込むことができます。
  5. NVIDIA Jetsonモジュールを搭載したその他のサードパーティ製デバイスをお持ちの場合は、コマンドラインでの書き込みを推奨します。
注

上記の方法1、4、5では、システムを書き込んでデバイスを起動した後、デバイスのターミナルでsudo apt update && sudo apt install nvidia-jetpack -yを実行し、残りの必要なJetPackコンポーネントをすべてインストールします。

Jetsonデバイス別JetPackサポート#

以下の表は、各NVIDIA JetsonデバイスでサポートされるNVIDIA JetPackのバージョンを示しています。

JetPack 4JetPack 5JetPack 6JetPack 7
Jetson Nano✅❌❌❌
Jetson TX2✅❌❌❌
Jetson Xavier NX✅✅❌❌
Jetson AGX Xavier✅✅❌❌
Jetson AGX Orin❌✅✅✅
Jetson Orin NX❌✅✅✅
Jetson Orin Nano❌✅✅✅
Jetson AGX Thor❌❌❌✅

Dockerでクイックスタート#

NVIDIA JetsonでUltralytics YOLO26をすぐに使い始めるには、Jetson向けのビルド済みDockerイメージを実行するのが最も簡単です。上記の表を参照し、使用するJetsonデバイスに応じたJetPackバージョンを選択してください。

t=ultralytics/ultralytics:latest-jetson-jetpack4
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t
JetPack 7のDockerおよびTensorRTサポート

latest-nvidia-arm64イメージは、CUDA 13.4とTensorRT 11.4を含むNVIDIA PyTorch 26.10を使用します。NVIDIAは互換性表で、PyTorch向けにJetPack 7.1を掲載していますが、TensorRT 11はJetPackをサポートしていません。Thorも対象外です。このイメージは、サポート対象のホスト上でPyTorchのワークロードを実行する場合にのみ使用してください。JetsonでTensorRTにエクスポートする場合は、以下のネイティブインストールと、お使いのJetPackリリースでサポートされているTensorRT 10.xランタイムを使用してください。ThorまたはOrinでJetPack 7.2を使用する場合は、コンテナを個別に検証する必要があります。対象のGPUとTensorRTのバージョンに合わせてエンジンを再ビルドしてください。

JetPack 4、5、6のイメージについては、引き続きNVIDIA JetsonでTensorRTを使用するをご覧ください。上記のJetPack 7.1イメージはPyTorchワークロード専用です。

ネイティブインストールを開始する#

Dockerを使用せずにネイティブインストールする場合は、以下の手順を参照してください。

JetPack 7.2で実行する#

Ultralyticsパッケージをインストールする#

JetsonにUltralyticsパッケージをインストールします。モデルを初めてエクスポートする際にエクスポート用の依存関係が自動でインストールされるため、ここでは基本パッケージのみが必要です。このガイドでは、Jetsonデバイスで最高の性能を発揮するNVIDIA TensorRTへのエクスポートに焦点を当てます。

  1. パッケージリストを更新し、pipをインストールして最新バージョンにアップグレードする

    sudo apt update
    sudo apt install python3-pip -y
    pip install -U pip
  2. ultralytics pipパッケージをインストールする

    pip install ultralytics
  3. デバイスを再起動する

    sudo reboot

PyTorchとTorchvisionをインストールする#

上記のultralyticsのインストールではTorchとTorchvisionがインストールされます。ただし、pipでインストールされるこれら2つのパッケージは、CUDA 13を実行するJetPack 7.2デバイスと互換性がないため、手動でインストールする必要があります。

JP7.2に応じてtorchとtorchvisionをインストールする

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu130

onnxruntime-gpuをインストールする#

お使いのJetPack、Python、CUDAのバージョンに合ったONNX Runtime GPUホイールを使用してください。現在のPyPIリリースにはARM64ホイールが含まれていますが、JetPackの各リリースに対応するデバイス固有のパッケージの代わりにはなりません。

Python3.12をサポートするonnxruntime-gpu 1.24.0をダウンロードしてインストールします。

pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.24.0-cp312-cp312-linux_aarch64.whl

JetPack 6.1で実行する#

Ultralyticsパッケージをインストールする#

JetsonにUltralyticsパッケージをインストールします。モデルを初めてエクスポートする際にエクスポート用の依存関係が自動でインストールされるため、ここでは基本パッケージのみが必要です。このガイドでは、Jetsonデバイスで最高の性能を発揮するNVIDIA TensorRTへのエクスポートに焦点を当てます。

  1. パッケージリストを更新し、pipをインストールして最新バージョンにアップグレードする

    sudo apt update
    sudo apt install python3-pip -y
    pip install -U pip
  2. ultralytics pipパッケージをインストールする

    pip install ultralytics
  3. デバイスを再起動する

    sudo reboot

PyTorchとTorchvisionをインストールする#

上記のultralyticsのインストールではTorchとTorchvisionがインストールされます。ただし、pipでインストールされるこれら2つのパッケージは、ARM64アーキテクチャを採用するJetsonプラットフォームと互換性がないため、ビルド済みのPyTorch pip wheelを手動でインストールし、Torchvisionをソースからコンパイルするかインストールする必要があります。

JP6.1に応じてtorch 2.10.0とtorchvision 0.25.0をインストールする

pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.10.0-cp310-cp310-linux_aarch64.whl
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.25.0-cp310-cp310-linux_aarch64.whl
注

Jetson向けPyTorchページで、さまざまなJetPackバージョンに対応するPyTorchの各バージョンを確認できます。PyTorchとTorchvisionの互換性に関する詳しい一覧については、PyTorchとTorchvisionの互換性ページをご覧ください。

torch 2.10.0との依存関係の問題を修正するには、cuDSSをインストールしてください。

wget https://developer.download.nvidia.com/compute/cudss/0.7.1/local_installers/cudss-local-tegra-repo-ubuntu2204-0.7.1_0.7.1-1_arm64.deb
sudo dpkg -i cudss-local-tegra-repo-ubuntu2204-0.7.1_0.7.1-1_arm64.deb
sudo cp /var/cudss-local-tegra-repo-ubuntu2204-0.7.1/cudss-*-keyring.gpg /usr/share/keyrings/
sudo apt-get update
sudo apt-get -y install cudss

onnxruntime-gpuをインストールする#

お使いのJetPack、Python、CUDAのバージョンに合ったONNX Runtime GPUホイールを使用してください。現在のPyPIリリースにはARM64ホイールが含まれていますが、JetPackの各リリースに対応するデバイス固有のパッケージの代わりにはなりません。

利用可能なonnxruntime-gpuパッケージは、JetPackバージョン、Pythonバージョン、その他の互換性情報別に整理されたJetson Zoo ONNX Runtime互換性マトリックスで確認できます。

Python 3.10をサポートするJetPack 6の場合、onnxruntime-gpu 1.23.0をインストールできます。

pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.23.0-cp310-cp310-linux_aarch64.whl

または、onnxruntime-gpu 1.20.0の場合は次のようにします。

pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.20.0-cp310-cp310-linux_aarch64.whl

JetPack 5.1.2で実行する#

Ultralyticsパッケージをインストールする#

JetsonにUltralyticsパッケージをインストールします。モデルを初めてエクスポートする際にエクスポート用の依存関係が自動でインストールされるため、ここでは基本パッケージのみが必要です。このガイドでは、Jetsonデバイスで最高の性能を発揮するNVIDIA TensorRTへのエクスポートに焦点を当てます。

  1. パッケージリストを更新し、pipをインストールして最新バージョンにアップグレードする

    sudo apt update
    sudo apt install python3-pip -y
    pip install -U pip
  2. ultralytics pipパッケージをインストールする

    pip install ultralytics
  3. デバイスを再起動する

    sudo reboot

PyTorchとTorchvisionをインストールする#

上記のultralyticsのインストールではTorchとTorchvisionがインストールされます。ただし、pipでインストールされるこれら2つのパッケージは、ARM64アーキテクチャを採用するJetsonプラットフォームと互換性がないため、ビルド済みのPyTorch pip wheelを手動でインストールし、Torchvisionをソースからコンパイルするかインストールする必要があります。

  1. 現在インストールされているPyTorchとTorchvisionをアンインストールする

    pip uninstall torch torchvision
  2. JP5.1.2に応じてtorch 2.1.0とtorchvision 0.16.2をインストールする

    pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl
    pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.16.2+c6f3977-cp38-cp38-linux_aarch64.whl
注

Jetson向けPyTorchページで、さまざまなJetPackバージョンに対応するPyTorchの各バージョンを確認できます。PyTorchとTorchvisionの互換性に関する詳しい一覧については、PyTorchとTorchvisionの互換性ページをご覧ください。

onnxruntime-gpuをインストールする#

お使いのJetPack、Python、CUDAのバージョンに合ったONNX Runtime GPUホイールを使用してください。現在のPyPIリリースにはARM64ホイールが含まれていますが、JetPackの各リリースに対応するデバイス固有のパッケージの代わりにはなりません。

JetPackのバージョン、Pythonのバージョン、その他の互換性情報で整理された、利用可能なすべてのonnxruntime-gpuパッケージは、Jetson Zoo ONNX Runtime互換性マトリックスで確認できます。Python3.8をサポートするonnxruntime-gpu 1.17.0をダウンロードしてインストールします。

wget https://nvidia.box.com/shared/static/zostg6agm00fb6t5uisw51qi6kpcuwzd.whl -O onnxruntime_gpu-1.17.0-cp38-cp38-linux_aarch64.whl
pip install onnxruntime_gpu-1.17.0-cp38-cp38-linux_aarch64.whl
注

onnxruntime-gpuはNumPyを自動的に最新バージョンにアップグレードするため、発生する問題を解決するにはNumPy 1.23.5を再インストールします。

pip install numpy==1.23.5

NVIDIA JetsonでTensorRTを使用する#

Ultralyticsがサポートするすべてのモデルエクスポート形式の中で、TensorRTはNVIDIA Jetsonデバイス上で最も高い推論性能を発揮するため、JetsonへのデプロイにはTensorRTを最もおすすめします。エクスポートする前に、お使いのJetPackリリース用に提供されているTensorRT Pythonバインディングをインストールし、python3 -c "import tensorrt; print(tensorrt.__version__)"で動作を確認してください。JetPack 6/7では、サポートされているTensorRT 10.xランタイムを使用してください。TensorRT 11に置き換えないでください。セットアップ手順と高度な使い方については、TensorRT専用の統合ガイドをご覧ください。

ビルド環境をローカルで構成せずに、ブラウザーからエクスポートすることもできます。Ultralytics PlatformのモデルエクスポートタブでTensorRTと対象のJetsonを選択してください。Thorの選択肢は、実機のThorハードウェアで検証されています。Orinの6つの選択肢では、現在AGX-Orin上でビルドされた候補エンジンが生成されます。デプロイする前に、対象のOrin SKUで検証してください。

TensorRTエンジンはデバイス固有です

TensorRTは、ビルド時にエンジンのプロファイリングと最適化を行うGPU上でエンジンを調整します。対象デバイスのGPUアーキテクチャとTensorRT/CUDAランタイムを一致させ、ダウンロードしたすべてのエンジンをデプロイ先のデバイスで検証してください。同じアーキテクチャのOrin SKUであっても、必ず移植できるとは限りません。また、最良の結果を得るには、INT8キャリブレーションを対象デバイスで実行してください。

モデルをTensorRTに変換して推論を実行する#

PyTorch形式のYOLO26nモデルをTensorRTに変換し、エクスポートしたモデルで推論を実行します。

例
from ultralytics import YOLO

# YOLO26n PyTorchモデルを読み込む
model = YOLO("yolo26n.pt")

# モデルをTensorRTにエクスポートする
model.export(format="engine")  # 'yolo26n.engine'を作成します

# エクスポートしたTensorRTモデルを読み込む
trt_model = YOLO("yolo26n.engine")

# 推論を実行
results = trt_model("https://ultralytics.com/images/bus.jpg")

NVIDIA Deep Learning Accelerator(DLA)を使用する#

NVIDIA Deep Learning Accelerator(DLA)は、NVIDIA Jetsonデバイスに組み込まれた専用ハードウェアコンポーネントであり、電力効率と性能を高めるためにディープラーニング推論を最適化します。GPUから処理をオフロードして、より負荷の高い処理にGPUを使用できるようにすることで、DLAは高いスループットを維持しながらモデルの消費電力を抑えます。そのため、組み込みシステムやリアルタイムAIアプリケーションに最適です。

TensorRTとDLAの互換性

NVIDIAによると、DLAをサポートする最後のリリースはTensorRT 10.7です。TensorRT 11.xはDLAをサポートしていません。お使いのJetPackバージョンでサポートされている、DLA対応のTensorRTリリースを使用してください。TensorRT 11は、GPUのみへのエクスポートも含め、JetPackをサポートしていません。

以下のJetsonデバイスにはDLAハードウェアが搭載されています。

JetsonデバイスDLAコア数DLA最大周波数
Jetson AGX Orinシリーズ21.6 GHz
Jetson Orin NX 16GB2614 MHz
Jetson Orin NX 8GB1614 MHz
Jetson AGX Xavierシリーズ21.4 GHz
Jetson Xavier NXシリーズ21.1 GHz
例
from ultralytics import YOLO

# YOLO26n PyTorchモデルを読み込む
model = YOLO("yolo26n.pt")

# DLAを有効にしてモデルをTensorRTにエクスポートする(FP16またはINT8でのみ動作)
model.export(format="engine", device="dla:0", quantize=16)  # dla:0またはdla:1はDLAコアに対応します

# エクスポートしたTensorRTモデルを読み込む
trt_model = YOLO("yolo26n.engine")

# 推論を実行
results = trt_model("https://ultralytics.com/images/bus.jpg")
注

DLAにエクスポートすると、一部のレイヤーがDLAでの実行をサポートしておらず、GPUで実行される場合があります。このフォールバックによりレイテンシが増加し、推論性能全体に影響することがあります。そのため、DLAはTensorRTをGPUのみで実行する場合と比べて、推論レイテンシを削減することを主な目的としていません。DLAの主な目的は、スループットを向上させ、電力効率を高めることです。

NVIDIA JetsonでのYOLO26ベンチマーク#

Ultralyticsチームは、PyTorch、TorchScript、ONNX、OpenVINO、TensorRT、TF SavedModel、TF GraphDef、TF Lite、MNN、NCNN、ExecuTorchの11種類のモデル形式について、速度と精度を測定するYOLO26のベンチマークを実施しました。ベンチマークは、NVIDIA Jetson AGX Thor Developer Kit、NVIDIA Jetson AGX Orin Developer Kit(64GB)、NVIDIA Jetson Orin Nano Super Developer Kit、およびJetson Orin NX 16GBを搭載したSeeed Studio reComputer J4012で、FP32精度、デフォルトの入力画像サイズ640を使用して実施しました。

比較チャート#

すべてのモデルエクスポートはNVIDIA Jetsonで動作しますが、以下の比較チャートにはPyTorch、TorchScript、TensorRTのみが含まれています。すべてのエクスポート形式のベンチマークは、このチャートの後のセクションで確認できます。

NVIDIA Jetson AGX Thor 開発者キット#

Jetson AGX Thor Benchmarks
Ultralytics 8.3.226でベンチマーク

NVIDIA Jetson AGX Orin 開発者キット(64GB)#

Jetson AGX Orin Benchmarks
Ultralytics 8.4.32でベンチマーク

NVIDIA Jetson Orin Nano Super 開発者キット#

Jetson Orin Nano Super Benchmarks
Ultralytics 8.4.33でベンチマーク

NVIDIA Jetson Orin NX 16GB#

Jetson Orin NX 16GB Benchmarks
Ultralytics 8.4.33でベンチマーク

詳細な比較表#

次の表は、5種類のYOLO26モデル(YOLO26n、YOLO26s、YOLO26m、YOLO26l、YOLO26x)を11種類の形式(PyTorch、TorchScript、ONNX、OpenVINO、TensorRT、TF SavedModel、TF GraphDef、TF Lite、MNN、NCNN、ExecuTorch)でベンチマークした結果を示しています。各組み合わせのステータス、サイズ、mAP50-95(B)指標、推論時間を掲載しています。

NVIDIA Jetson AGX Thor 開発者キット#

性能
形式ステータスディスク上のサイズ(MB)mAP50-95(B)推論時間(ms/im)
PyTorch✅5.30.47987.39
TorchScript✅9.80.47894.21
ONNX✅9.50.47676.58
OpenVINO✅10.10.479417.50
TensorRT(FP32)✅13.90.47911.90
TensorRT(FP16)✅7.60.47971.39
TensorRT(INT8)✅6.50.42731.52
TF SavedModel✅25.70.476447.24
TF GraphDef✅9.50.476445.98
TF Lite✅9.90.4764182.04
MNN✅9.40.478421.83

Ultralytics 8.4.7でベンチマークを実施

注

推論時間には前処理と後処理は含まれません。

NVIDIA Jetson AGX Orin 開発者キット(64GB)#

性能
形式ステータスディスク上のサイズ(MB)mAP50-95(B)推論時間(ms/im)
PyTorch✅5.30.479011.58
TorchScript✅9.80.47704.60
ONNX✅9.50.47709.87
OpenVINO✅9.60.482028.80
TensorRT(FP32)✅11.50.47704.18
TensorRT(FP16)✅7.90.47892.62
TensorRT(INT8)✅5.40.46402.30
TF SavedModel✅24.60.476071.10
TF GraphDef✅9.50.476070.02
TF Lite✅9.90.4760227.94
MNN✅9.40.476032.46
NCNN✅9.30.481029.93

Ultralytics 8.4.32でベンチマークを実施

注

推論時間には前処理と後処理は含まれません。

NVIDIA Jetson Orin Nano Super 開発者キット#

性能
形式ステータスディスク上のサイズ(MB)mAP50-95(B)推論時間(ms/im)
PyTorch✅5.30.479015.60
TorchScript✅9.80.477012.60
ONNX✅9.50.476015.76
OpenVINO✅9.60.482056.23
TensorRT(FP32)✅11.30.47707.53
TensorRT(FP16)✅8.10.48004.57
TensorRT(INT8)✅5.30.44903.80
TF SavedModel✅24.60.4760118.33
TF GraphDef✅9.50.4760116.30
TF Lite✅9.90.4760286.00
MNN✅9.40.476068.77
NCNN✅9.30.481047.50

Ultralytics 8.4.33でベンチマークを実施

注

推論時間には前処理と後処理は含まれません。

NVIDIA Jetson Orin NX 16GB#

性能
形式ステータスディスク上のサイズ(MB)mAP50-95(B)推論時間(ms/im)
PyTorch✅5.30.479913.90
TorchScript✅9.80.478711.60
ONNX✅9.50.476314.18
OpenVINO✅9.60.481940.19
TensorRT(FP32)✅11.40.47707.01
TensorRT(FP16)✅8.00.47894.13
TensorRT(INT8)✅5.50.44893.49
TF SavedModel✅24.60.476492.34
TF GraphDef✅9.50.476492.06
TF Lite✅9.90.4764254.43
MNN✅9.40.476048.55
NCNN✅9.30.480534.31

Ultralytics 8.4.33でベンチマークを実施

注

推論時間には前処理と後処理は含まれません。

異なるバージョンのNVIDIA Jetsonハードウェアで実施されたSeeed Studioによるベンチマークの取り組みをさらに見る。

結果を再現する#

すべてのエクスポート形式で上記のUltralyticsベンチマークを再現するには、次のコードを実行してください。

例
from ultralytics import YOLO

# YOLO26n PyTorchモデルを読み込む
model = YOLO("yolo26n.pt")

# すべてのエクスポート形式でCOCO128データセットを使用してYOLO26nの速度と精度をベンチマークします
results = model.benchmark(data="coco128.yaml", imgsz=640)

ベンチマーク結果は、システムのハードウェアとソフトウェアの構成や、ベンチマーク実行時のシステムの負荷によって異なる場合があります。最も信頼性の高い結果を得るには、data='coco.yaml'(検証画像5000枚)のような、画像数の多いデータセットを使用してください。

NVIDIA Jetsonを使用する際のベストプラクティス#

NVIDIA JetsonでYOLO26の性能を最大限に引き出すには、以下のベストプラクティスに従ってください。

  1. MAX Power Modeを有効にする

    JetsonでMAX Power Modeを有効にすると、すべてのCPUコアとGPUコアがオンになります。

    sudo nvpmodel -m 0
  2. Jetson Clocksを有効にする

    Jetson Clocksを有効にすると、すべてのCPUコアとGPUコアが最大周波数で動作します。

    sudo jetson_clocks
  3. Jetson Statsアプリケーションをインストールする

    jetson-statsアプリケーションを使うと、システムコンポーネントの温度やCPU、GPU、RAMの使用率を確認できるほか、電力モードの変更、最大クロックの設定、JetPack情報の確認ができます。

    sudo apt update
    sudo pip install jetson-stats
    sudo reboot
    jtop
jtop dashboard from jetson-stats showing Jetson CPU, GPU, and memory utilization

NVIDIA Jetson向けメモリ最適化のヒント#

Jetsonデバイスでは、使用可能なメモリがボトルネックになることがよくあります。特に、Jetson Orin Nano(8 GB)やOrin NX 8 GBなど、メモリ容量の少ないモデルでは顕著です。以下のヒントは、実用的でリスクの低い変更であり、組み合わせることで数百メガバイトのメモリを解放し、より大きなYOLOモデルの実行や、追加の並列ワークロードのサポートが可能になります。詳しくは、Jetsonのメモリ効率を最大化する方法に関するNVIDIAのブログをご覧ください。

1. ヘッドレス(GUIなし)で起動する#

JetsonをSSH経由で接続している場合や、ディスプレイを接続せずに本番環境のアプライアンスとして実行している場合は、デスクトップ環境とディスプレイサーバーを無効にすることで、最大865 MBのRAMを回収できます。

sudo systemctl set-default multi-user.target
sudo reboot

後からデスクトップ環境を復元するには、次のコマンドを実行します。

sudo systemctl set-default graphical.target
sudo reboot

2. 使用していないシステムサービスを無効にする#

重要でないバックグラウンドサービス(Bluetooth、接続管理ツール、使用していないハードウェアデーモン)は、合計で約32 MBを消費します。実行中のサービスを一覧表示し、デプロイで必要のないものを無効にしてください。

# List running services
systemctl list-units --type=service --state=running

# Disable a service
sudo systemctl disable SERVICE_NAME

3. メモリ使用量をプロファイリングする#

最適化する前に、実際にどのプロセスがRAMを消費しているかを特定してください。procrankはプロセスをPSS(Proportional Set Size)順に並べ替えます。PSSは、他のプロセスと共有されるページを含む、プロセスにマッピングされた物理RAMページの合計であるRSS(Resident Set Size)よりも、プロセスごとの実際のメモリ使用量を正確に反映します。

git clone https://github.com/csimmonds/procrank_linux.git
cd procrank_linux && make
sudo ./procrank

プロセスごとのGPUおよびNvMap(CUDA/ビデオパイプライン)の割り当てを確認するには、次のコマンドを実行します。

sudo cat /sys/kernel/debug/nvmap/iovmm/clients

4. 本番環境ではディスプレイなしで推論を実行する#

ライブプレビューが不要な推論パイプラインでは、ディスプレイ関連コンポーネント(Tiler、OSD、DisplaySink)を無効にすると、パイプラインだけで200 MB以上を節約できます。Ultralytics YOLOでは、ビューアーを非表示にし、代わりに結果をディスクに書き込みます。

例
from ultralytics import YOLO

model = YOLO("yolo26n.engine")

# show=Falseはディスプレイウィンドウを表示しないようにし、save=Trueは注釈付きの出力をディスクに書き込みます
results = model.predict(source="video.mp4", show=False, save=True)

累積効果#

最適化おおよそのメモリ節約量
デスクトップGUIを無効にする~865 MB
使用していないOSサービスを無効にする~32 MB
ヘッドレス推論パイプライン(ディスプレイなし)~200+ MB
合計(簡単にできる対策)~1 GB以上

これらの変更を組み合わせることは、メモリに制約のあるデバイスでTensorRT INT8モデルを使用する場合に特に効果的です。より大きなモデルをメモリに収められるかどうかを左右することがあります。

次のステップ#

詳しい情報やサポートについては、Ultralytics YOLO26ドキュメントをご覧ください。

よくある質問#

  • NVIDIA JetsonデバイスにUltralytics YOLO26をデプロイするには、まずNVIDIA JetPack SDKをJetsonデバイスに書き込みます。次に、すぐにセットアップできるビルド済みDockerイメージを使用するか、必要なパッケージを手動でインストールしてください。

  • YOLO26モデルはNVIDIA Jetson AGX Thor、AGX Orin、Orin Nano Super、Orin NXデバイスでベンチマークされており、TensorRT形式が最高の推論性能を発揮します。詳細比較表のセクションには、モデルとエクスポート形式ごとのmAP50-95および推論時間が掲載されています。

  • NVIDIA JetsonでYOLO26モデルをデプロイする場合は、TensorRTを推奨します。モデルをJetsonのGPU向けに最適化することで、すべてのエクスポート形式の中で最速の推論を実現します。

  • NVIDIA JetsonにPyTorchとTorchvisionをインストールするには、まずpip経由でインストールされた既存のバージョンをアンインストールします。次に、JetsonのARM64アーキテクチャに対応するPyTorchとTorchvisionのバージョンを手動でインストールします。この手順の詳しい説明は、PyTorchとTorchvisionをインストールするセクションをご覧ください。

  • YOLO26を使用してNVIDIA Jetsonのパフォーマンスを最大限に高めるには、次のベストプラクティスに従ってください。

    1. MAX Power Modeを有効にして、すべてのCPUコアとGPUコアを使用します。
    2. Jetson Clocksを有効にして、すべてのコアを最大周波数で動作させます。
    3. Jetson Statsアプリケーションをインストールして、システム指標を監視します。

    コマンドや詳しい情報については、NVIDIA Jetsonを使用する際のベストプラクティスセクションをご覧ください。

  • メモリ容量の少ないJetsonデバイスでは、使用可能なRAMがボトルネックになることがよくあります。次の3つの簡単な対策を組み合わせると、1 GB以上を回収できます。

    1. ヘッドレス起動に切り替える(sudo systemctl set-default multi-user.target)ことで、デスクトップGUIを無効にします(約865 MBを節約)。
    2. Bluetoothや接続管理ツールなどの使用していないサービスを無効にすることで、約32 MBを節約できます。
    3. YOLOのpredict呼び出しでshow=Falseを設定してディスプレイなしで推論を実行すると、ディスプレイパイプライン用のメモリ割り当てを回避できます(200 MB以上を節約)。

    procrankを使用してプロセスごとのRAM使用量をプロファイリングし、sudo cat /sys/kernel/debug/nvmap/iovmm/clientsを使用してGPUの割り当てを確認してください。詳しくは、メモリ最適化のヒントセクションをご覧ください。

  • JetPack 6に同梱されているTensorRT 10.3.0には既知の問題があり、NMSなし(nms=False)またはNMS組み込み(nms=True)の出力でINT8エンジンをビルドできません。Ultralyticsはこの組み合わせを検出すると、NMSなしのエクスポートではone-to-manyヘッドを選択し、nms=Trueのエクスポートをエラーで停止します。

    これらのINT8エクスポートを再び利用するには、TensorRTを新しいバージョン(例:10.7.0以降)にアップグレードしてください。

    wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/arm64/cuda-keyring_1.1-1_all.deb
    sudo dpkg -i cuda-keyring_1.1-1_all.deb
    sudo apt-get update
    sudo apt-get install -y tensorrt

    アップグレード後、エクスポートを再実行してください。詳細については、GitHubのissue #23841とissue #26655をご覧ください。

コメント194

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

  1. pknowlerGitHub

    Struggling with this on a new Jetson Orin Nano JP6.1. All good following the steps and installs to give torch.cuda.is_available as TRUE. The TensorRT export fails though with a number of dependency errors and I can’t re-install it with anything. Any pointers please?

    1
    1. Glenn JocherUltralytics

      @pknowler it seems like the dependency errors during TensorRT export might stem from compatibility issues. Please ensure you’ve installed the required JetPack-compatible versions of PyTorch, Torchvision, and TensorRT as outlined in the Jetson Quick Start Guide. Additionally, verify that onnxruntime-gpu and cuSPARSELt are correctly installed per the guide. If the issue persists, you can try reinstalling TensorRT using the NVIDIA SDK Manager for your JetPack version. Let me know if you need further clarification!

    2. pknowlerGitHub

      Thank you. I will try again working through all of the steps and let you know how it goes!

    3. pknowlerGitHub

      I’ve tried again but this as far as I get… I have followed everything carefully.

      WARNING ⚠️ TensorRT requires GPU export, automatically assigning device=0 Ultralytics 8.3.57 🚀 Python-3.10.16 torch-2.5.0a0+872d972e41.nv24.08 CUDA:0 (Orin, 7620MiB) YOLO11n summary (fused): 238 layers, 2,616,248 parameters, 0 gradients, 6.5 GFLOPs

      PyTorch: starting from 'yolo11n.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) (1, 84, 8400) (5.4 MB)

      ONNX: starting export with onnx 1.17.0 opset 19... ONNX: slimming with onnxslim 0.1.46... ONNX: export success ✅ 3.1s, saved as 'yolo11n.onnx' (10.2 MB) requirements: Ultralytics requirement ['tensorrt>7.0.0,!=10.1.0'] not found, attempting AutoUpdate... error: subprocess-exited-with-error

      × python setup.py egg_info did not run successfully. │ exit code: 1 ╰─> [6 lines of output] Traceback (most recent call last): File "", line 2, in File "", line 34, in File "/tmp/pip-install-d0ljzl60/tensorrt-cu12_db0552ac431148489703f6f75df6764f/setup.py", line 71, in raise RuntimeError("TensorRT does not currently build wheels for Tegra systems") RuntimeError: TensorRT does not currently build wheels for Tegra systems [end of output]

      note: This error originates from a subprocess, and is likely not a problem with pip. error: metadata-generation-failed

      × Encountered error while generating package metadata. ╰─> See above for output.

      note: This is an issue with the package mentioned above, not pip. hint: See above for details. Retry 1/2 failed: Command 'pip install --no-cache-dir "tensorrt>7.0.0,!=10.1.0" ' returned non-zero exit status 1. error: subprocess-exited-with-error

      × python setup.py egg_info did not run successfully. │ exit code: 1 ╰─> [6 lines of output] Traceback (most recent call last): File "", line 2, in File "", line 34, in File "/tmp/pip-install-782zjqf9/tensorrt-cu12_44d261aea7c5489db3e9ce15cec8ee64/setup.py", line 71, in raise RuntimeError("TensorRT does not currently build wheels for Tegra systems") RuntimeError: TensorRT does not currently build wheels for Tegra systems [end of output]

      note: This error originates from a subprocess, and is likely not a problem with pip. error: metadata-generation-failed

      × Encountered error while generating package metadata. ╰─> See above for output.

      note: This is an issue with the package mentioned above, not pip. hint: See above for details.

    4. Glenn JocherUltralytics

      @pknowler it seems your TensorRT version is not compatible with the Jetson's ARM64 architecture. TensorRT does not provide pre-built Python wheels for Tegra systems. Please ensure you have TensorRT installed via the NVIDIA SDK Manager as part of the JetPack installation, and confirm compatibility with your JetPack version. The Jetson Quick Start Guide might also help clarify setup specifics. Let me know if further assistance is needed!

    5. pknowlerGitHub

      @glenn-jocher thank you. I have found the issue now. I am using miniconda and for some reason TensorRT Python bindings are not available in conda envs. So I can import Torch with no problem but the import TensorRT fails. I have re-installed without conda and all works as expected! 👍🏻

    1. Paula DerrengerUltralytics(編集済み)

      In terms of reducing inference time on your NVIDIA Jetson device, using TensorRT is generally recommended. TensorRT is specifically designed to provide high performance for NVIDIA hardware by optimizing deep learning models for inference. It accelerates models by fusing layers, pruning unused layers, and quantizing variables, among other optimizations. 🚀

      DeepStream, on the other hand, is more focused on streaming analytics and can utilize TensorRT-optimized models. For most cases, directly using TensorRT for model optimization is your go-to for minimizing inference times.

      Here's a quick example of exporting a YOLO model to TensorRT and running inference, tailored for your convenience:

      from ultralytics import YOLO
      
      # Load your YOLO model
      model = YOLO('yolo26n.pt')
      
      # Export to TensorRT format
      model.export(format='engine')
      
      # Load the TensorRT model
      trt_model = YOLO('yolo26n.engine')
      
      # Run inference using the TensorRT model
      results = trt_model('your_image_or_video.jpg')

      Feel free to explore more about deploying on NVIDIA Jetson with our Quick Start Guide for NVIDIA Jetson. Happy inferencing! 🌟

      2
    2. Paula DerrengerUltralytics(編集済み)

      Hey there! 😊 It looks like you're interested in speeding up your inference times. Between TensorRT and DeepStream on NVIDIA Jetson devices, TensorRT typically offers more direct optimization for reducing inference time for individual models by providing lower-level optimizations and quantization options.

      DeepStream is a comprehensive framework for building end-to-end video analytics applications, which utilizes TensorRT under the hood for model inference. DeepStream excels in scenarios involving video streams, multi-stream input, and complex pipelines involving multiple AI models and analytics. If your primary goal is solely to minimize inference time for a specific model, direct optimization via TensorRT can provide more focused improvements.

      A quick example of exporting a YOLO model to TensorRT:

      from ultralytics import YOLO
      
      # Load your YOLO model
      model = YOLO('yolo26n.pt')
      
      # Export to TensorRT format
      model.export(format='engine')  # This creates 'yolo26n.engine'
      
      # Done! Now you can use 'yolo26n.engine' for faster inference.

      However, if your application benefits from a broader video analytics pipeline, incorporating DeepStream into your workflow can optimize and streamline these processes on top of efficiently handling inference with TensorRT optimized models. 🚀

      Hope this gives you a clearer picture! If you have more questions, feel free to ask.

      1
  2. Yufeng Wu(編集済み)

    Hi, ultralytics team. I'm trying yolo26n-pose on Jetson orin agx 64gb and have this problem: I tried building engine with dynamic=true but failed, with the log saying ForeignNode[/model.23/Sigmoid.../model.23/Flatten] (Myelin) Skipping tactic ... Incompatible effective shapes in operation /model_23/Sub between: Unsqueeze_18_output_0 f32[1,2,33600] and Slice_output_0 f32[1,2,21504] Could not find any implementation for node {ForeignNode[/model.23/Sigmoid.../model.23/Flatten]} Is there a way to fix it?

    1. Glenn JocherUltralytics

      This indicates a TensorRT dynamic-shape profile failure in the pose head. As a workaround, export a fixed-resolution engine, e.g. yolo export model=yolo26n-pose.pt format=engine imgsz=640 batch=1 dynamic=False; build separate engines if multiple resolutions are required. If dynamic shapes are essential, please open a new issue with the full text log, yolo checks output, and JetPack/TensorRT/Ultralytics versions so we can reproduce it; see the TensorRT export guide.

  3. Haotian Gong(編集済み)

    Hi, everyone,

    I'd like to flag two issues with the Jetson installation guide that may need updating.


    1. PyTorch 2.10.0 / Torchvision 0.25.0 doesn't work on JetPack 6.1

    Following the "Start with naive installation" and "Run on JetPack 6.1" sections, I installed Pytorch 2.10.0 and Torchvision 0.25.0 as instructed.

    Running my script then throws:

    ImportError: libcublas.so.13: cannot open shared object file: No such file or directory

    So I have to install Pytorch 2.8.0 with the guide:

    https://forums.developer.nvidia.com/t/jetson-orin-nano-issues-running-yolo-ultralytics-due-to-pytorch-torchvision-compatibility-jetpack-6-x-cuda-12-6/365683/9

    And this version of Pytorch works. So maybe is the guide on Jetson obsolete or mistaken?


    2. CSI camera requires the JetPack-bundled OpenCV, not the PyPI one

    On Jetson, using a CSI camera (via nvarguscamerasrc) requires the OpenCV that ships with JetPack, because the PyPI opencv-python wheel on aarch64 is built without GStreamer support.

    However, pip install ultralytics pulls in opencv-python as a dependency, which shadows the JetPack-bundled version and silently breaks CSI camera pipelines.

    pip uninstall -y opencv-python opencv-python-headless
    sudo apt install -y python3-opencv   # JetPack-bundled OpenCV with GStreamer

    Thanks!

    1. Lakshantha DissanayakeUltralytics

      Hi @ZephyrKeXiner Could you please double check whether you are using JetPack 6.1 system with CUDA 12.6? I have just verified on my JetPack 6.1 system with CUDA 12.6 with torch-2.10.0 and torchvision-0.25.0 as mentioned in the Ultralytics Jetson Guide and it works well.

      For JetPack 6.1, output of cat /etc/nv_tegra_release should look like below:

      (env) nvidia@ubuntu:~/yolo26/ultralytics$ cat /etc/nv_tegra_release 
      # R36 (release), REVISION: 4.3, GCID: 38968081, BOARD: generic, EABI: aarch64, DATE: Wed Jan  8 01:49:37 UTC 2025
      # KERNEL_VARIANT: oot
      TARGET_USERSPACE_LIB_DIR=nvidia
      TARGET_USERSPACE_LIB_DIR_PATH=usr/lib/aarch64-linux-gnu/nvidia

      Could you also share yours please? Thanks!

      cc: @raimbekovm

      1
    2. Haotian Gong

      Hi @lakshanthad,

      My output of cat /etc/nv_tegra_release is below:

      $ cat /etc/nv_tegra_release 
      # R36 (release), REVISION: 5.0, GCID: 43688277, BOARD: generic, EABI: aarch64, DATE: Fri Jan 16 03:50:45 UTC 2026
      # KERNEL_VARIANT: oot
      TARGET_USERSPACE_LIB_DIR=nvidia
      TARGET_USERSPACE_LIB_DIR_PATH=usr/lib/aarch64-linux-gnu/nvidia

      I notice that the revision is 5.0 not 4.3. Maybe does it cause the error?

  4. smbunnGitHub(編集済み)

    I would have thought the Jetson Orin Nano could do more than 5 streams, the deepstream examples with cars handles 16 streams of 1080p at what appears to be full framerate.

    As a control systems engineer by training, edge devices seem a much better way to go so I prefer your jetson design. Even if one Jetson has an issue you are still processing 45 streams whereas a problem on your centralised server in option 2 takes everything down.

    Are you going to set up an MQTT feed for alerts from each stream? Maybe consider secondary processing and a buffer, so the edge device detects what it thinks is an issue and a centralised server grabs 5 seconds of video of the incident and double checks.

    Simon BUNN

    General


    From: Yash Patel @.> Sent: Friday, 22 May 2026 4:00 am To: ultralytics/ultralytics @.> Cc: Bunn, Simon @.>; Mention @.> Subject: Re: [ultralytics/ultralytics] guides/nvidia-jetson/ (Discussion #9942)

    Hi, I am designing an AI-based CCTV surveillance system for a residential society with 50 RTSP camera streams. My current architecture uses multiple NVIDIA Jetson Orin Nano Super Developer Kit devices for distributed inference processing. I ZjQcmQRYFpfptBannerStart Attention The sender's identity could not be verified and someone may be impersonating the sender. L'identité de l'expéditeur n'a pas pu être vérifiée et quelqu'un pourrait se faire passer pour l'expéditeur.

    ZjQcmQRYFpfptBannerEnd

    Hi, I am designing an AI-based CCTV surveillance system for a residential society with 50 RTSP camera streams. My current architecture uses multiple NVIDIA Jetson Orin Nano Super Developer Kit devices for distributed inference processing. I estimate that one Jetson Orin Nano Super (8GB) can process around 5 RTSP streams at usable real-time FPS. This requires approximately 10 Jetson devices for the full deployment. Each device costs around ₹33,000 (~USD 395). The total estimated hardware cost is ₹330,000 (~USD 3,950). I want to compare this setup against a centralized Linux-based custom PC/server with NVIDIA GPU acceleration under the same budget. The comparison focuses on AI inference performance, scalability, reliability, and 24/7 operational efficiency. The workload mainly includes multi-stream YOLO/object detection inference on live RTSP feeds. I want to determine which architecture provides the best computation-to-cost ratio for this surveillance use case.

    — Reply to this email directly, view it on GitHubhttps://urldefense.com/v3/__https://github.com/orgs/ultralytics/discussions/9942*discussioncomment-17006943__;Iw!!ElGdukoduuk!URiPjKkgDoMT_k2Y6pEd3XMEBGMDjhwgtQmwWXR9F4R4L7ymNloZD79NanOjYVg9YYmaARqyZGbgFv7U15KzgdcU$, or unsubscribehttps://urldefense.com/v3/__https://github.com/notifications/unsubscribe-auth/ABAAMILYUP7PPODNHDR3HC3434RYLAVCNFSM6AAAAABGAK2IGGVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTOMBQGY4TIMY__;!!ElGdukoduuk!URiPjKkgDoMT_k2Y6pEd3XMEBGMDjhwgtQmwWXR9F4R4L7ymNloZD79NanOjYVg9YYmaARqyZGbgFv7U1zjhi4YU$. Triage notifications on the go with GitHub Mobile for iOShttps://urldefense.com/v3/__https://apps.apple.com/app/apple-store/id1477376905?ct=notification-email&mt=8&pt=524675__;!!ElGdukoduuk!URiPjKkgDoMT_k2Y6pEd3XMEBGMDjhwgtQmwWXR9F4R4L7ymNloZD79NanOjYVg9YYmaARqyZGbgFv7U13gOq1qb$ or Androidhttps://urldefense.com/v3/__https://play.google.com/store/apps/details?id=com.github.android&referrer=utm_campaign*3Dnotification-email*26utm_medium*3Demail*26utm_source*3Dgithub__;JSUlJSU!!ElGdukoduuk!URiPjKkgDoMT_k2Y6pEd3XMEBGMDjhwgtQmwWXR9F4R4L7ymNloZD79NanOjYVg9YYmaARqyZGbgFv7U1zOl3XaF$. You are receiving this because you were mentioned.Message ID: @.***>

    1. Glenn JocherUltralytics

      5 streams on an Orin Nano Super is just a conservative YOLO/Python estimate; with a headless TensorRT or DeepStream pipeline, MAX power mode, and jetson_clocks, higher 1080p stream counts are definitely possible and depend heavily on the model size, input resolution, decode/encode, and any tracking or alert logic you add, so please drop your exact model, imgsz, FPS target, and RTSP resolution here and we can help size it more accurately using the Jetson deployment guide and DeepStream Jetson guide.

  5. yashpatel2010GitHub

    Hi, I am designing an AI-based CCTV surveillance system for a residential society with 50 RTSP camera streams. My current architecture uses multiple NVIDIA Jetson Orin Nano Super Developer Kit devices for distributed inference processing. I estimate that one Jetson Orin Nano Super (8GB) can process around 5 RTSP streams at usable real-time FPS. This requires approximately 10 Jetson devices for the full deployment. Each device costs around ₹33,000 (~USD 395). The total estimated hardware cost is ₹330,000 (~USD 3,950). I want to compare this setup against a centralized Linux-based custom PC/server with NVIDIA GPU acceleration under the same budget. The comparison focuses on AI inference performance, scalability, reliability, and 24/7 operational efficiency. The workload mainly includes multi-stream YOLO/object detection inference on live RTSP feeds. I want to determine which architecture provides the best computation-to-cost ratio for this surveillance use case.

  6. RotatingGiraffeGitHub

    Hi there, I am trying to run a fine-tuned YOLO26 based model for an OBB task on a Xavier NX running JetPack 5. I am using your container (ultralytics/ultralytics:latest-jetson-jetpack5) and trying to compile from PyTorch to TensorRT. I get the error: "mymodel.pt requires numpy>=1.26.1, however numpy==1.23.5 is installed."

    Previously I have successfully the file on my host machine from PT to ONNX, copied ONNX to Jetson and then used tensorrtexec to compile to Engine. But the resulting models did not create any bounding boxes.

    I wanted to ask if JetPack 5 even supports Yolo26 or if the model contains some incompatible layers? YOLO11 OBB works fine which I find extra-weird. Or is there likely an error somewhere else in my script?

    1. Glenn JocherUltralytics

      Thanks for posting this here—JetPack 5 on Xavier NX is supported for YOLO26/TensorRT in our Jetson guide, so the numpy>=1.26.1 error points more to an environment/checkpoint mismatch than unsupported OBB layers; please paste the full text traceback and yolo checks output, and note that an engine built with tensorrtexec can still produce empty OBB results if the Ultralytics export metadata/postprocessing is not preserved.

    2. RotatingGiraffeGitHub

      Hi there, I tried to create a minimal reproducible example for you, based on what I am doing. I hope it helps with debugging.

      The yolo checks you asked for is in the script output, along with the export script. I've also included the bit where I export via trtexex just for the sake of completion - it might very well be possible that I omit required metadata with this. My prefered goal would be that everything works via the Ultralytics Python API, but I had to search for workaround due to the NumPy error when compiling PT files.

      I am now using the Ultralytics base image in the MRE which I hoped would be easier to debug for us. The NumPy error persists on the new image. Previously I was using something built upon l4t-ml.

      Additionally, ONNX fails with an error ( `GLIBCXX_3.4.29' not found I think it was) but that is not a concern to me since I engine would be my prefered way to go. I have not installed any additional packages and kept it very vanilla (see dockerfile). The MRE also weirdly produced a new error during engine inference, but I'd say lets just focus on getting the Ultralytics native pipeline to work and then maybe all the other issues were just from my workarounds and disappear.

      Execution Command
      sudo docker compose up --build
      
      Directory Structure
      obb-test-repro/
       ┣ 📂data/
       ┃ ┗ 📜mydataset.yaml
       ┣ 📂models/
       ┃ ┣ 📜my-yolo26m-model.onnx
       ┃ ┗ 📜my-yolo26m-model.pt
       ┣ 📂src/
       ┃ ┗ 📜main.py
       ┣ 📜docker-compose.yml
       ┣ 📜Dockerfile
       ┗ 📜requirements.txt
      
      Dockerfile
      FROM ultralytics/ultralytics:latest-jetson-jetpack5
      
      WORKDIR /app
      
      # Copy the test app
      COPY src/ ./src/
      
      # Run the test
      CMD ["python3", "src/main.py"]
      
      docker-compose.yml
      version: '3.8'
      
      services:
        obb-test-jp5:
          image: obb-test:latest
          container_name: obb_test_jp5
          build:
            context: .
            dockerfile: Dockerfile
          runtime: nvidia
          network_mode: host
          ipc: host
          restart: "no"
          volumes:
            - ./models:/app/models
            - ./data:/app/data
          environment:
            - NVIDIA_VISIBLE_DEVICES=all
            - NVIDIA_DRIVER_CAPABILITIES=all
      
      main.py
      """
      Minimal OBB model test script.
      
      Behavior:
      - Runs `yolo checks` to output environment details.
      - Uses files in `/app/models` (container path mapped from `obb-test/models`).
      - Expects two files (hard-coded):
        - `/app/models/my-yolo26m-model.pt` (optional) — used for Ultralytics native export
        - `/app/models/my-yolo26m-model.onnx` (optional) — used for trtexec compilation
      - Runs both export methods (if files exist) and validates inference on each compiled engine using mydataset dataset.
      """
      
      import logging
      import sys
      import subprocess
      import os
      from pathlib import Path
      from ultralytics import YOLO
      
      # Configure logging
      logging.basicConfig(
          level=logging.INFO,
          format='%(asctime)s - %(levelname)s - %(message)s'
      )
      logger = logging.getLogger(__name__)
      
      
      def run_yolo_checks():
          """Execute yolo checks via CLI to log environment details."""
          logger.info("=" * 60)
          logger.info("Environment Verification (yolo checks)")
          logger.info("=" * 60)
          try:
              res = subprocess.run(["yolo", "checks"], capture_output=True, text=True, check=True)
              logger.info("\n" + res.stdout.strip())
          except subprocess.CalledProcessError as e:
              logger.error(f"yolo checks failed:\n{e.stderr}")
          except FileNotFoundError:
              logger.error("yolo CLI command not found. Ensure ultralytics is installed in this environment.")
      
      
      def test_export_to_engine():
          models_dir = Path("/app/models")
          pt_path = models_dir / "my-yolo26m-model.pt"
          onnx_path = models_dir / "my-yolo26m-model.onnx"
          dataset_yaml = "/app/data/mydataset.yaml"
      
          logger.info("=" * 60)
          logger.info("Minimal OBB Test - Export & Validation")
          logger.info("=" * 60)
      
          engines_tested = []
      
          # Part 1: Ultralytics native export (PT -> Engine)
          if pt_path.exists():
              try:
                  logger.info(f"\nRunning Ultralytics native export for: {pt_path.name}")
                  model = YOLO(str(pt_path))
                  exported = model.export(format="engine", imgsz=1024, device=0, half=True)
                  
                  # Resolve the exported engine path
                  native_engine = str(exported) if isinstance(exported, (str, Path)) else str(pt_path.with_suffix('.engine'))
                  
                  if os.path.exists(native_engine):
                      logger.info(f"Ultralytics export successfully produced: {native_engine}")
                      engines_tested.append(native_engine)
                  else:
                      logger.error(f"Ultralytics export completed, but engine file was not found at {native_engine}")
              except Exception as e:
                  logger.error(f"Ultralytics native export failed: {e}", exc_info=True)
          else:
              logger.info(f"PT file not found ({pt_path}); skipping Ultralytics native export.")
      
          # Part 2: trtexec compilation (ONNX -> Engine)
          if onnx_path.exists():
              try:
                  logger.info(f"\nRunning trtexec to compile ONNX: {onnx_path.name}")
                  trt_engine = str(onnx_path.with_suffix('.trt.engine'))
                  cmd = [
                      "/usr/src/tensorrt/bin/trtexec",
                      f"--onnx={onnx_path}",
                      f"--saveEngine={trt_engine}",
                      "--fp16",
                      "--memPoolSize=workspace:768", # Prevents Out of Memory
                  ]
                  logger.info(f"Running command: {' '.join(cmd)}")
                  res = subprocess.run(cmd, capture_output=True, text=True)
                  
                  if res.returncode != 0:
                      logger.error("trtexec compilation failed.")
                      logger.error(f"trtexec stderr:\n{res.stderr}")
                  else:
                      if os.path.exists(trt_engine):
                          logger.info(f"trtexec successfully saved engine to {trt_engine}")
                          engines_tested.append(trt_engine)
                      else:
                          logger.error(f"trtexec returned success, but engine file was not found at {trt_engine}")
              except Exception as e:
                  logger.error(f"trtexec execution failed: {e}", exc_info=True)
          else:
              logger.info(f"ONNX file not found ({onnx_path}); skipping trtexec compilation.")
      
          if not engines_tested:
              logger.error("\nNo engines are available to test. Exiting validation phase.")
              return False
      
          # Part 3: Inference Validation
          validation_success = True
          for eng in engines_tested:
              try:
                  logger.info(f"\nValidating inference with engine: {eng}")
                  
                  model = YOLO(eng, task="obb")
                  metrics = model.val(data=dataset_yaml, imgsz=1024, batch=1, verbose=False)
                  
                  logger.info(f"Validation metrics for {eng}: mAP50-95={metrics.box.map:.4f}, mAP50={metrics.box.map50:.4f}")
              except Exception as e:
                  logger.error(f"Validation failed on {eng}: {e}", exc_info=True)
                  validation_success = False
      
          logger.info("\nExecution complete.")
          return validation_success
      
      
      if __name__ == "__main__":
          run_yolo_checks()
          
          try:
              success = test_export_to_engine()
              logger.info("\n" + "=" * 60)
              if success:
                  logger.info("✓ Test passed")
              else:
                  logger.info("✗ Test failed")
              logger.info("=" * 60)
              sys.exit(0 if success else 1)
          except Exception as e:
              logger.error(f"Unhandled script exception: {e}", exc_info=True)
              sys.exit(1)
      
      Output
      obb_test_jp5  | Creating new Ultralytics Settings v0.0.6 file ✅ 
      obb_test_jp5  | View Ultralytics Settings with 'yolo settings' or at '/root/.config/Ultralytics/settings.json'
      obb_test_jp5  | Update Settings with 'yolo settings key=value', i.e. 'yolo settings runs_dir=path/to/dir'. For help see https://docs.ultralytics.com/quickstart/#ultralytics-settings.
      obb_test_jp5  | 2026-05-14 12:51:35,392 - INFO - ============================================================
      obb_test_jp5  | 2026-05-14 12:51:35,392 - INFO - Environment Verification (yolo checks)
      obb_test_jp5  | 2026-05-14 12:51:35,392 - INFO - ============================================================
      obb_test_jp5  | 2026-05-14 12:51:50,554 - INFO - 
      obb_test_jp5  | Ultralytics 8.4.50 🚀 Python-3.8.10 torch-2.1.0a0+41361538.nv23.06 CUDA:0 (Xavier, 6833MiB)
      obb_test_jp5  | Setup complete ✅ (2 CPUs, 6.7 GB RAM, 91.7/107.6 GB disk)
      obb_test_jp5  | 
      obb_test_jp5  | OS                     Linux-5.10.216-tegra-aarch64-with-glibc2.29
      obb_test_jp5  | Environment            Docker
      obb_test_jp5  | Python                 3.8.10
      obb_test_jp5  | Install                git
      obb_test_jp5  | Path                   /ultralytics/ultralytics
      obb_test_jp5  | RAM                    6.67 GB
      obb_test_jp5  | Disk                   91.7/107.6 GB
      obb_test_jp5  | CPU                    ARMv8 Processor rev 0 (v8l)
      obb_test_jp5  | CPU count              2
      obb_test_jp5  | GPU                    Xavier, 6833MiB
      obb_test_jp5  | GPU count              1
      obb_test_jp5  | CUDA                   11.4
      obb_test_jp5  | 
      obb_test_jp5  | numpy                  ✅ 1.23.5>=1.23.0
      obb_test_jp5  | matplotlib             ✅ 3.7.5>=3.3.0
      obb_test_jp5  | opencv-python-headless ✅ 4.13.0.92>=4.6.0
      obb_test_jp5  | pillow                 ✅ 10.4.0>=7.1.2
      obb_test_jp5  | pyyaml                 ✅ 6.0.3>=5.3.1
      obb_test_jp5  | requests               ✅ 2.32.4>=2.23.0
      obb_test_jp5  | scipy                  ✅ 1.10.1>=1.4.1
      obb_test_jp5  | torch                  ✅ 2.1.0a0+41361538.nv23.6>=1.8.0
      obb_test_jp5  | torchvision            ✅ 0.16.2+c6f3977>=0.9.0
      obb_test_jp5  | psutil                 ✅ 7.2.2>=5.8.0
      obb_test_jp5  | polars                 ✅ 1.8.2>=0.20.0
      obb_test_jp5  | ultralytics-thop       ✅ 2.0.19>=2.0.18
      obb_test_jp5  | torch                  ✅ 2.1.0a0+41361538.nv23.6!=2.4.0,>=1.8.0; sys_platform == "win32"
      obb_test_jp5  | 2026-05-14 12:51:50,562 - INFO - ============================================================
      obb_test_jp5  | 2026-05-14 12:51:50,563 - INFO - Minimal OBB Test - Export & Validation
      obb_test_jp5  | 2026-05-14 12:51:50,564 - INFO - ============================================================
      obb_test_jp5  | 2026-05-14 12:51:50,565 - INFO - 
      obb_test_jp5  | Running Ultralytics native export for: my-yolo26m-model.pt
      obb_test_jp5  | 2026-05-14 12:51:51,353 - ERROR - Ultralytics native export failed: ERROR ❌️ /app/models/my-yolo26m-model.pt requires numpy>=1.26.1, however numpy==1.23.5 is installed.
      obb_test_jp5  | Traceback (most recent call last):
      obb_test_jp5  |   File "/ultralytics/ultralytics/nn/tasks.py", line 1466, in torch_safe_load
      obb_test_jp5  |     ckpt = _load()
      obb_test_jp5  |   File "/ultralytics/ultralytics/nn/tasks.py", line 1463, in _load
      obb_test_jp5  |     return torch_load(file, map_location="cpu")
      obb_test_jp5  |   File "/ultralytics/ultralytics/utils/patches.py", line 181, in torch_load
      obb_test_jp5  |     return torch.load(*args, **kwargs)
      obb_test_jp5  |   File "/usr/local/lib/python3.8/dist-packages/torch/serialization.py", line 877, in load
      obb_test_jp5  |     return _load(opened_zipfile, map_location, pickle_module, **pickle_load_args)
      obb_test_jp5  |   File "/usr/local/lib/python3.8/dist-packages/torch/serialization.py", line 1253, in _load
      obb_test_jp5  |     result = unpickler.load()
      obb_test_jp5  |   File "/usr/local/lib/python3.8/dist-packages/torch/serialization.py", line 1246, in find_class
      obb_test_jp5  |     return super().find_class(mod_name, name)
      obb_test_jp5  | ModuleNotFoundError: No module named 'numpy._core'
      obb_test_jp5  | 
      obb_test_jp5  | The above exception was the direct cause of the following exception:
      obb_test_jp5  | 
      obb_test_jp5  | Traceback (most recent call last):
      obb_test_jp5  |   File "src/minimal.py", line 58, in test_export_to_engine
      obb_test_jp5  |     model = YOLO(str(pt_path))
      obb_test_jp5  |   File "/ultralytics/ultralytics/models/yolo/model.py", line 76, in __init__
      obb_test_jp5  |     super().__init__(model=model, task=task, verbose=verbose)
      obb_test_jp5  |   File "/ultralytics/ultralytics/engine/model.py", line 144, in __init__
      obb_test_jp5  |     self._load(model, task=task)
      obb_test_jp5  |   File "/ultralytics/ultralytics/engine/model.py", line 283, in _load
      obb_test_jp5  |     self.model, self.ckpt = load_checkpoint(weights)
      obb_test_jp5  |   File "/ultralytics/ultralytics/nn/tasks.py", line 1537, in load_checkpoint
      obb_test_jp5  |     ckpt, weight = torch_safe_load(weight)  # load ckpt
      obb_test_jp5  |   File "/ultralytics/ultralytics/nn/tasks.py", line 1489, in torch_safe_load
      obb_test_jp5  |     raise ModuleNotFoundError(
      obb_test_jp5  | ModuleNotFoundError: ERROR ❌️ /app/models/my-yolo26m-model.pt requires numpy>=1.26.1, however numpy==1.23.5 is installed.
      obb_test_jp5  | 2026-05-14 12:51:51,382 - INFO - 
      obb_test_jp5  | Running trtexec to compile ONNX: my-yolo26m-model.onnx
      obb_test_jp5  | 2026-05-14 12:51:51,382 - INFO - Running command: /usr/src/tensorrt/bin/trtexec --onnx=/app/models/my-yolo26m-model.onnx --saveEngine=/app/models/my-yolo26m-model.trt.engine --fp16 --memPoolSize=workspace:768
      obb_test_jp5  | 2026-05-14 13:21:39,214 - INFO - trtexec successfully saved engine to /app/models/my-yolo26m-model.trt.engine
      obb_test_jp5  | 2026-05-14 13:21:39,217 - INFO - 
      obb_test_jp5  | Validating inference with engine: /app/models/my-yolo26m-model.trt.engine
      obb_test_jp5  | Ultralytics 8.4.50 🚀 Python-3.8.10 torch-2.1.0a0+41361538.nv23.06 CUDA:0 (Xavier, 6833MiB)
      obb_test_jp5  | Loading /app/models/my-yolo26m-model.trt.engine for TensorRT inference...
      obb_test_jp5  | [05/14/2026-13:21:41] [TRT] [I] Loaded engine size: 43 MiB
      obb_test_jp5  | [05/14/2026-13:21:45] [TRT] [I] [MemUsageChange] Init cuBLAS/cuBLASLt: CPU +260, GPU +306, now: CPU 648, GPU 5277 (MiB)
      obb_test_jp5  | [05/14/2026-13:21:46] [TRT] [I] [MemUsageChange] Init cuDNN: CPU +82, GPU +156, now: CPU 730, GPU 5433 (MiB)
      obb_test_jp5  | [05/14/2026-13:21:46] [TRT] [I] [MemUsageChange] TensorRT-managed allocation in engine deserialization: CPU +0, GPU +41, now: CPU 0, GPU 41 (MiB)
      obb_test_jp5  | [05/14/2026-13:21:46] [TRT] [I] [MemUsageChange] Init cuBLAS/cuBLASLt: CPU +0, GPU +28, now: CPU 687, GPU 5422 (MiB)
      obb_test_jp5  | [05/14/2026-13:21:46] [TRT] [I] [MemUsageChange] Init cuDNN: CPU +0, GPU +32, now: CPU 687, GPU 5454 (MiB)
      obb_test_jp5  | [05/14/2026-13:21:46] [TRT] [I] [MemUsageChange] TensorRT-managed allocation in IExecutionContext creation: CPU +0, GPU +92, now: CPU 0, GPU 133 (MiB)
      obb_test_jp5  | Setting batch=1 input of shape (1, 3, 1024, 1024)
      obb_test_jp5  | 2026-05-14 13:21:54,562 - INFO - generated new fontManager
      obb_test_jp5  | val: Fast image access ✅ (ping: 1.1±0.9 ms, read: 479.2±146.1 MB/s, size: 2563.4 KB)
      val: Scanning /app/data/labels/rec26.cache... 2940 images, 26 backgrounds, 0 corrupt: 100% ━━━━━━━━━━━━ 2940/2940 14.4Mit/s 0.0s
      obb_test_jp5  | 2026-05-14 13:22:01,033 - ERROR - Validation failed on /app/models/my-yolo26m-model.trt.engine: CUDA error: no kernel image is available for execution on the device
      obb_test_jp5  | CUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.
      obb_test_jp5  | For debugging consider passing CUDA_LAUNCH_BLOCKING=1.
      obb_test_jp5  | Compile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.
      obb_test_jp5  | Traceback (most recent call last):
      obb_test_jp5  |   File "src/minimal.py", line 114, in test_export_to_engine
      obb_test_jp5  |     metrics = model.val(data=dataset_yaml, imgsz=1024, batch=1, verbose=False)
      obb_test_jp5  |   File "/ultralytics/ultralytics/engine/model.py", line 615, in val
      obb_test_jp5  |     validator(model=self.model)
      obb_test_jp5  |   File "/usr/local/lib/python3.8/dist-packages/torch/utils/_contextlib.py", line 115, in decorate_context
      obb_test_jp5  |     return func(*args, **kwargs)
      obb_test_jp5  |   File "/ultralytics/ultralytics/engine/validator.py", line 210, in __call__
      obb_test_jp5  |     model.warmup(imgsz=(1 if pt else self.args.batch, self.data["channels"], imgsz, imgsz))  # warmup
      obb_test_jp5  |   File "/ultralytics/ultralytics/nn/autobackend.py", line 313, in warmup
      obb_test_jp5  |     non_max_suppression(warmup_boxes)  # warmup NMS
      obb_test_jp5  |   File "/ultralytics/ultralytics/utils/nms.py", line 154, in non_max_suppression
      obb_test_jp5  |     i = torchvision.ops.nms(boxes, scores, iou_thres)
      obb_test_jp5  |   File "/usr/local/lib/python3.8/dist-packages/torchvision/ops/boxes.py", line 41, in nms
      obb_test_jp5  |     return torch.ops.torchvision.nms(boxes, scores, iou_threshold)
      obb_test_jp5  |   File "/usr/local/lib/python3.8/dist-packages/torch/_ops.py", line 646, in __call__
      obb_test_jp5  |     return self._op(*args, **kwargs or {})
      obb_test_jp5  | RuntimeError: CUDA error: no kernel image is available for execution on the device
      obb_test_jp5  | CUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.
      obb_test_jp5  | For debugging consider passing CUDA_LAUNCH_BLOCKING=1.
      obb_test_jp5  | Compile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.
      obb_test_jp5  | 
      obb_test_jp5  | 2026-05-14 13:22:01,521 - INFO - 
      obb_test_jp5  | Execution complete.
      obb_test_jp5  | 2026-05-14 13:22:01,524 - INFO - 
      obb_test_jp5  | ============================================================
      obb_test_jp5  | 2026-05-14 13:22:01,526 - INFO - ✗ Test failed
      obb_test_jp5  | 2026-05-14 13:22:01,529 - INFO - ============================================================
      obb_test_jp5 exited with code 1

      Export Device

      This is a bit of info on where my ONNX files come from and what my PC environment looks like where I compiled them.

      Yolo Checks on the ONNX Export Device
      Ultralytics 8.4.48 🚀 Python-3.13.9 torch-2.11.0+cu130 CPU (AMD Ryzen 5 5600G with Radeon Graphics)
      Setup complete ✅ (12 CPUs, 15.0 GB RAM, 744.1/878.1 GB disk)
      
      OS                     Linux-6.17.0-23-generic-x86_64-with-glibc2.39
      Environment            Linux
      Python                 3.13.9
      Install                git
      Path                   /home/myuser/projects/myproject/.venv/lib/python3.13/site-packages/ultralytics
      RAM                    15.01 GB
      Disk                   744.1/878.1 GB
      CPU                    AMD Ryzen 5 5600G with Radeon Graphics
      CPU count              12
      GPU                    None
      GPU count              None
      CUDA                   None
      
      numpy                  ✅ 2.4.4>=1.23.0
      matplotlib             ✅ 3.10.9>=3.3.0
      opencv-python          ✅ 4.13.0.92>=4.6.0
      pillow                 ✅ 12.2.0>=7.1.2
      pyyaml                 ✅ 6.0.3>=5.3.1
      requests               ✅ 2.33.1>=2.23.0
      scipy                  ✅ 1.17.1>=1.4.1
      torch                  ✅ 2.11.0>=1.8.0
      torch                  ✅ 2.11.0!=2.4.0,>=1.8.0; sys_platform == "win32"
      torchvision            ✅ 0.26.0>=0.9.0
      psutil                 ✅ 7.2.2>=5.8.0
      polars                 ✅ 1.40.1>=0.20.0
      ultralytics-thop       ✅ 2.0.19>=2.0.18
      Export Code
      from ultralytics import YOLO
      
      # 1. Load the model weights
      model_path = "my-yolo26m-model.pt"
      model = YOLO(model_path)
      
      # 2. Export the model
      # Configured for OBB (Oriented Bounding Boxes) and legacy TensorRT compatibility
      success = model.export(
          format="onnx", 
          imgsz=1024,      # Target resolution
          opset=13,       # ONNX operator set version, also tried 12
          simplify=True,   # I hoped this would help
          task="obb",
          half=False,      # I tried this with True and False
          end2end=False    # For legacy TensorRT support...?
      )
      
      print(f"Export successful: {success}")
      YOLO26m-obb summary (fused): 175 layers, 23,443,236 parameters, 0 gradients, 71.5 GFLOPs
      
      PyTorch: starting from 'my-yolo26m-model.pt' with input shape (1, 3, 1024, 1024) BCHW and output shape(s) (1, 6, 21504) (90.8 MB)
      
      ONNX: starting export with onnx 1.21.0 opset 13...
      ONNX: slimming with onnxslim 0.1.93...
      ONNX: export success ✅ 2.5s, saved as 'my-yolo26m-model.onnx' (81.3 MB)
      
      Export complete (4.3s)

      Old Container

      Jut in case it is relevant, this is the yolo checks of my self-made container which is based on l4t-ml.

      root@xaviernx-desktop:/app# yolo checks
      WARNING ⚠️ user config directory '/root/.config/Ultralytics' is not writable, using '/tmp/Ultralytics'. Set YOLO_CONFIG_DIR to override.
      Creating new Ultralytics Settings v0.0.6 file ✅ 
      View Ultralytics Settings with 'yolo settings' or at '/tmp/Ultralytics/settings.json'
      Update Settings with 'yolo settings key=value', i.e. 'yolo settings runs_dir=path/to/dir'. For help see https://docs.ultralytics.com/quickstart/#ultralytics-settings.
      Ultralytics 8.4.49 🚀 Python-3.8.10 torch-2.0.0+nv23.05 CUDA:0 (Xavier, 6833MiB)
      Setup complete ✅ (2 CPUs, 6.7 GB RAM, 84.9/107.6 GB disk)
      
      OS                     Linux-5.10.216-tegra-aarch64-with-glibc2.29
      Environment            Docker
      Python                 3.8.10
      Install                pip
      Path                   /usr/local/lib/python3.8/dist-packages/ultralytics
      RAM                    6.67 GB
      Disk                   84.9/107.6 GB
      CPU                    ARMv8 Processor rev 0 (v8l)
      CPU count              2
      GPU                    Xavier, 6833MiB
      GPU count              1
      CUDA                   11.4
      
      numpy                  ✅ 1.23.5>=1.23.0
      matplotlib             ✅ 3.7.5>=3.3.0
      opencv-python          ❌ (not installed)>=4.6.0
      pillow                 ✅ 10.2.0>=7.1.2
      pyyaml                 ✅ 5.3.1>=5.3.1
      requests               ✅ 2.32.4>=2.23.0
      scipy                  ✅ 1.10.1>=1.4.1
      torch                  ✅ 2.0.0+nv23.5>=1.8.0
      torch                  ✅ 2.0.0+nv23.5!=2.4.0,>=1.8.0; sys_platform == "win32"
      torchvision            ✅ 0.15.1a0+42759b1>=0.9.0
      psutil                 ✅ 5.9.6>=5.8.0
      polars                 ❌ (not installed)>=0.20.0
      ultralytics-thop       ❌ (not installed)>=2.0.18
    3. Murat Raimbekov

      Thanks for the detailed MRE. I reproduced the numpy failure end-to-end with torch.save/torch.load and have a verified fix. There are two independent issues here.

      1. numpy._core / "requires numpy>=1.26.1" — root cause and fix

      Your .pt was saved on your PC with numpy 2.x / Python 3.13, so the checkpoint pickle embeds the numpy-2 numpy._core module path. JetPack 5 on Xavier NX runs Python 3.8, whose maximum numpy is 1.24.x, and Xavier cannot move to JetPack 6 (Orin-only). I verified that even numpy 1.26.x does not fully read such a checkpoint, so "upgrade numpy" is not a real option on JP5.

      The reliable fix is a small compatibility shim that aliases numpy._core to the legacy numpy.core, injected before the model is loaded. I confirmed this loads a numpy-2 torch.save checkpoint correctly under numpy 1.23.5 with the model and all fields intact. Put this at the very top of your main.py, before from ultralytics import YOLO:

      import sys, numpy, numpy.core
      sys.modules["numpy._core"] = numpy.core
      for _s in ("multiarray", "numeric", "umath", "_multiarray_umath"):
          try:
              sys.modules[f"numpy._core.{_s}"] = __import__(f"numpy.core.{_s}", fromlist=[_s])
          except Exception:
              pass

      Alternatively, fix the checkpoint once on the PC (where numpy 2.x can read it) so the device never needs the shim — load it and re-save it after converting the auxiliary numpy fields, then copy the new .pt to the Jetson.

      2. Empty boxes / CUDA error: no kernel image is available for execution on the device

      These are separate from numpy:

      • The trtexec-built engine produces no detections because a raw trtexec engine carries none of the Ultralytics export metadata, so the OBB decoding/post-processing is never applied. Build the engine on the Jetson with Ultralytics directly from the .pt (after applying the shim above) so metadata is embedded: YOLO("model.pt").export(format="engine", imgsz=1024, half=True, device=0).
      • no kernel image is available is raised inside torchvision.ops.nms on the GPU: the PyTorch/torchvision in ultralytics/ultralytics:latest-jetson-jetpack5 is built for Orin (SM 8.7), while Xavier NX is SM 7.2. That is exactly why YOLO11 OBB works in your older l4t-ml-based container (torch 2.0.0+nv23.5) but the official image fails. Recommended path: stay on the container that already works on your Xavier, pip install ultralytics opencv-python-headless there, and run the Ultralytics export(format="engine") + val() entirely on-device.

      TL;DR: the numpy error is a pickle module-path mismatch from the numpy-2 export PC (fix with the shim above — verified), and the empty/CUDA errors are a raw-trtexec metadata loss plus a torch/torchvision build that doesn't target Xavier's SM 7.2.

      1
    4. RotatingGiraffeGitHub

      Hi there, thank you for the help! I just recently got around to trying out the shim and now everything works just fine, thank you for your help!

  7. yashpatel2010GitHub

    How to run deepstream for YOLO26 models in my jetson orin nano developer kit?

    Is there any documentation for deepstream on jetson? I don't want any installation errors of version missmatch.

    So give me any perfect guide link so that I will not miss anything while installation and run inference on live RTSP streams

    1. yashpatel2010GitHub

      Thanks for your reply. Just onemore doubt to clear. docker pull nvcr.io/nvidia/deepstream:7.1-triton-multiarch

      if I use above docker container for my jetpack6.1 so it there is no issue of version missmatch of deepstream right?

      is it works very well with Yolo26 deepstream settings which is showing in this doc? https://docs.ultralytics.com/guides/deepstream-nvidia-jetson/

      what is your recommendation to run Multiple RTSP streams with deepstream with docker containers or without docker containers manual installation?

    2. Glenn JocherUltralytics

      Yes, nvcr.io/nvidia/deepstream:7.1-triton-multiarch is the correct DeepStream 7.1 Jetson container for JetPack 6.1, but it still depends on the host having the JetPack BSP and NVIDIA container runtime installed, so it lowers mismatch risk rather than removing it completely; for YOLO26 + RTSP, the DeepStream multi-stream section is the right reference, and I’d suggest native setup first since that’s the install path used in the guide, then move to Docker once your pipeline is stable. (docs.ultralytics.com)

    3. yashpatel2010GitHub(編集済み)

      Thanks. For native setup Is it good to install deepstream 7.1 while installing jetpack6.1 only?

  8. githubwaltGitHub

    Installing torch 2.11.0 from the official website pytorch.org on an AGX Orin 64Gb (dev kit) with JP6.2.2 or installing torch 2.10.0 and torchvision 0.25.0 following this page, give complaints about not being compatible with the Compute Capability (CC) of my machine which has 8.7, whatever that means. Only installing the previous versions torch 2.8.0 and torchvision 0.23.0 do work.

    I understand that torch needs to be tailored specifically for the Jetson family and that is what this page is all about, so why do I have this issue if I follow the instructions given here? Is it because I am on Jetpack 6.2.2 and here it's 6.1?

    1. githubwaltGitHub

      I forgot the warning and error output when running a python test script:

      UserWarning: Found GPU0 Orin which is of compute capability (CC) 8.7.The following list shows the CCs this version of PyTorch was built for and the hardware CCs it supports:- 8.0 which supports hardware CC >=8.0,<9.0 except {8.7}- 9.0 which supports hardware CC >=9.0,<10.0

      torch.AcceleratorError CUDA error: no kernel image is available for execution on the device

    2. Glenn JocherUltralytics

      Thanks, that traceback helps — CC 8.7 is the AGX Orin GPU architecture, and no kernel image is available means the installed PyTorch wheel was built without sm_87 support. So yes, this is most likely a JetPack/PyTorch wheel mismatch: the native steps in the JetPack 6.1 section don’t necessarily map cleanly to JP6.2.2, even though the page includes JP6.2 benchmark coverage. For now I’d stick with the working torch 2.8.0 + torchvision 0.23.0 pair or use the JetPack 6 Docker setup; if you want us to check your exact environment, please post yolo checks and the full text traceback here in the discussion.

    3. Glenn JocherUltralytics

      No worries — the duplicate is fine, and if you later confirm a stable JP6.2.2 + PyTorch pairing on AGX Orin, please add it here so we can reflect it in the Jetson guide.

    4. githubwaltGitHub

      Will do. Now trying to get the most out of the AGX. Experimenting with number of workers on a batch size of 16. So far 12 workers gave memory issues ... I chose 12 because of 12 cores, but that was a little too much. Now running with 8 workers ... so far so good. To be continued 🙂

    5. githubwaltGitHub

      Hi Glenn, I can confirm a stable JP6.2.2 + Pytorch (torch 2.8.0 and torchvision 0.23.0) on the AGX Orin.