【TensorRT】推論高速化実践ガイド2026（ONNX変換からデプロイまで）

はじめに

深層学習モデルの本番環境へのデプロイにおいて、推論の低レイテンシと高スループットは最も重要な要件の一つです。訓練に比べて推論は長期間にわたり繰り返し実行されるため、わずかな最適化が全体のコストとユーザー体験に大きな影響を与えます。NVIDIAが提供するTensorRTは、NVIDIA GPU上での推論実行を最大限に高速化するための高性能SDKです。モデルを最適化し、ランタイムエンジンに変換することで、フレームワーク単体での実行と比較して数倍から数十倍の高速化を実現できます。

本記事では、2026年現在の最新の実践に基づき、PyTorchで訓練したモデルをTensorRTで最適化し、本番環境にデプロイするまでの一連の流れを詳細に解説します。ONNXを経由した変換、最新の量子化技術（INT8/FP8）、そしてTriton Inference Serverを用いたスケーラブルなデプロイまで、実運用を想定した手順をコード例と共に紹介します。

前提条件・必要な環境

以下の環境を前提として進めます。バージョンは2026年時点の最新安定版を想定しています。

• ハードウェア: NVIDIA GPU (Ampereアーキテクチャ以降を推奨。FP8量子化にはHopper以降が必要)

ソフトウェア:

• OS: Ubuntu 22.04 LTS または 24.04 LTS
• NVIDIA Driver: 550以上
• CUDA: 12.4以上
• cuDNN: 9.0以上
• Python: 3.10以上
• 主要ライブラリ: PyTorch 2.4+, torchvision, onnx, onnx-simplifier, tensorrt, nvidia-triton-client

TensorRTのインストールは、NVIDIA公式のNGCコンテナを利用することを強くお勧めします。環境構築が簡便で、依存関係の問題を回避できます。

# Dockerを使用したNGC TensorRTコンテナの起動例
docker run --gpus all -it --shm-size=1g --ulimit memlock=-1 -v $(pwd):/workspace nvcr.io/nvidia/tensorrt:24.xx-py3

手順1: PyTorchモデルからONNX形式へのエクスポート

TensorRTは多くのフレームワークのモデルを直接サポートしていますが、PyTorchモデルを変換する際のデファクトスタンダードはONNX形式を経由する方法です。ONNXはモデルの構造とパラメータを保存する中間フォーマットです。

まずは、単純なResNet-50モデルをONNX形式にエクスポートする例を示します。重要な点は、モデルを推論モード(model.eval())に設定し、ダミーの入力データ(dummy_input)を用意することです。動的バッチサイズに対応させるため、入力テンソルの次元にはbatch軸を動的(Noneまたは-1)に定義します。

import torch
import torchvision.models as models

# 1. モデルのロードと推論モード設定
model = models.resnet50(pretrained=True)
model.eval()

# 2. ダミー入力の作成 (バッチサイズは動的)
batch_size = 1  # エクスポート時のサンプルバッチサイズ
dummy_input = torch.randn(batch_size, 3, 224, 224, device='cuda')

# 3. ONNX形式でエクスポート
input_names = ["input"]
output_names = ["output"]
dynamic_axes = {
    'input': {0: 'batch_size'},  # 0番目の次元(バッチ)を動的に
    'output': {0: 'batch_size'}
}

torch.onnx.export(
    model,
    dummy_input,
    "resnet50.onnx",
    input_names=input_names,
    output_names=output_names,
    dynamic_axes=dynamic_axes,
    opset_version=17,  # ONNX Opsetバージョン
    do_constant_folding=True
)
print("ONNXモデルをエクスポートしました: resnet50.onnx")

エクスポート後、ONNXモデルの構造を検証・最適化するためにonnx-simplifierを使用することをお勧めします。これにより、冗長な演算が除去され、TensorRTでの変換成功率が向上します。

python -m onnxsim resnet50.onnx resnet50_sim.onnx

手順2: ONNXモデルからTensorRTエンジンへの変換（FP32/FP16）

最適化されたONNXモデルを、TensorRTエンジン（.planまたは.engineファイル）に変換します。ここでは、Python APIを使用した変換方法を示します。まずは基本のFP32およびFP16精度での変換です。

import tensorrt as trt

logger = trt.Logger(trt.Logger.WARNING)
builder = trt.Builder(logger)
network = builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH))
parser = trt.OnnxParser(network, logger)

# 1. ONNXファイルの読み込みとパース
with open("resnet50_sim.onnx", "rb") as f:
    if not parser.parse(f.read()):
        for error in range(parser.num_errors):
            print(parser.get_error(error))
        raise RuntimeError("ONNXのパースに失敗しました")

# 2. ビルダー設定の構成
config = builder.create_builder_config()
config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, 2 << 30)  # 2GBワークスペース

# 3. 精度設定 (FP16の有効化)
if builder.platform_has_fast_fp16:
    config.set_flag(trt.BuilderFlag.FP16)
    print("FP16モードを有効化します")

# 4. プロファイリングの有効化 (動的形状最適化のため)
profile = builder.create_optimization_profile()
profile.set_shape(
    input_names[0],
    min=(1, 3, 224, 224),   # 最小バッチサイズ
    opt=(8, 3, 224, 224),   # 最適バッチサイズ
    max=(32, 3, 224, 224)   # 最大バッチサイズ
)
config.add_optimization_profile(profile)

# 5. エンジンのビルドとシリアライズ
serialized_engine = builder.build_serialized_network(network, config)
if serialized_engine is None:
    raise RuntimeError("エンジンのビルドに失敗しました")

with open("resnet50_fp16.engine", "wb") as f:
    f.write(serialized_engine)
print("TensorRTエンジンを保存しました: resnet50_fp16.engine")

ポイント: set_memory_pool_limitでワークスペースメモリを確保し、create_optimization_profileで推論時に変化しうる入力サイズ（ここではバッチサイズ）の範囲を定義します。これにより、動的バッチサイズに対応した最適化が行われます。

手順3: 高度な最適化 - INT8/FP8量子化

更なる高速化と省メモリ化のために、量子化は極めて有効な技術です。TensorRTはINT8（8ビット整数）と、最新GPUではFP8（8ビット浮動小数点）量子化をサポートしています。

INT8量子化（ポストトレーニング量子化）

INT8量子化では、キャリブレーションと呼ばれるプロセスで、浮動小数点モデルの活性化分布を代表するデータセット（キャリブレーションセット）を用いてスケーリング係数を決定します。

import numpy as np

# ... (前段のビルダー、ネットワーク作成は同じ) ...

config = builder.create_builder_config()
config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, 2 << 30)

# FP16に加えてINT8フラグを設定
if builder.platform_has_fast_fp16:
    config.set_flag(trt.BuilderFlag.FP16)
if builder.platform_has_fast_int8:
    config.set_flag(trt.BuilderFlag.INT8)
    print("INT8量子化を有効化します")

    # INT8キャリブレーションの設定
    class MyCalibrator(trt.IInt8EntropyCalibrator2):
        def __init__(self, batch_size=8):
            super().__init__()
            self.batch_size = batch_size
            self.calibration_data = np.random.randn(batch_size, 3, 224, 224).astype(np.float32)
            self.current_index = 0
            self.device_input = cuda.mem_alloc(self.calibration_data.nbytes)

        def get_batch_size(self):
            return self.batch_size

        def get_batch(self, names):
            if self.current_index >= 1:  # ここでは1バッチ分のみ使用
                return None
            cuda.memcpy_htod(self.device_input, self.calibration_data)
            self.current_index += 1
            return [int(self.device_input)]

        def read_calibration_cache(self):
            return None

        def write_calibration_cache(self, cache):
            with open("calibration.cache", "wb") as f:
                f.write(cache)

    config.int8_calibrator = MyCalibrator()

# ... (プロファイル設定、エンジンビルドは同じ) ...

FP8量子化（Hopperアーキテクチャ以降）

FP8量子化は、INT8よりも精度劣化が少ないとされる新しい形式です。設定は非常にシンプルです。

# ... (ビルダー、ネットワーク作成は同じ) ...

config = builder.create_builder_config()
config.set_flag(trt.BuilderFlag.FP8)
config.set_flag(trt.BuilderFlag.FP16)  # FP8とFP16を併用可能
print("FP8量子化を有効化します")

# ... (プロファイル設定、エンジンビルドは同じ) ...

注意点: FP8はNVIDIA Hopperアーキテクチャ（例: H100）以降のGPUでのみハードウェアサポートされます。また、モデルによってはFP8への変換がサポートされていない演算が含まれる場合があります。

手順4: TensorRTエンジンを用いた推論実行

生成されたエンジンファイルを読み込み、推論を実行します。ここでは、Python Runtime APIを使用した例を示します。

import tensorrt as trt
import pycuda.driver as cuda
import pycuda.autoinit
import numpy as np

# 1. エンジンの読み込み
logger = trt.Logger(trt.Logger.WARNING)
with open("resnet50_fp16.engine", "rb") as f, trt.Runtime(logger) as runtime:
    engine = runtime.deserialize_cuda_engine(f.read())

# 2. 実行コンテキストの作成
context = engine.create_execution_context()

# 3. 入出力バッファの確保
input_idx = engine.get_binding_index("input")
output_idx = engine.get_binding_index("output")

# 動的バッチサイズに対応した形状設定
batch_size = 4
context.set_binding_shape(input_idx, (batch_size, 3, 224, 224))

# GPUメモリの割り当て
input_host = np.random.randn(batch_size, 3, 224, 224).astype(np.float32)
output_host = np.empty(context.get_binding_shape(output_idx), dtype=np.float32)

input_device = cuda.mem_alloc(input_host.nbytes)
output_device = cuda.mem_alloc(output_host.nbytes)

# 4. 推論実行
stream = cuda.Stream()
cuda.memcpy_htod_async(input_device, input_host, stream)
context.execute_async_v2(bindings=[int(input_device), int(output_device)], stream_handle=stream.handle)
cuda.memcpy_dtoh_async(output_host, output_device, stream)
stream.synchronize()

print(f"推論完了。出力形状: {output_host.shape}")

手順5: Triton Inference Serverによる本番環境デプロイ

単一のスクリプトでの推論から、本番環境での高可用性・高スループットなサービス提供へ移行するには、Triton Inference Serverが業界標準です。TensorRTエンジンをTritonでサービス化する方法を説明します。

まず、Tritonが要求する以下のディレクトリ構造を作成します。

model_repository/
└── resnet50_trt
    ├── 1
    │   └── model.plan  # 手順2で作成したエンジンファイル
    └── config.pbtxt    # モデル設定ファイル

config.pbtxtの内容例です。プラットフォーム、入力出力、動的バッチ設定などを記述します。

name: "resnet50_trt"
platform: "tensorrt_plan"
max_batch_size: 32

input [
  {
    name: "input"
    data_type: TYPE_FP32
    dims: [ 3, 224, 224 ]
  }
]
output [
  {
    name: "output"
    data_type: TYPE_FP32
    dims: [ 1000 ]
  }
]

dynamic_batching {
  preferred_batch_size: [ 8, 16 ]
  max_queue_delay_microseconds: 100
}

次に、Dockerを使用してTriton Inference Serverを起動します。

docker run --gpus=all --rm -p 8000:8000 -p 8001:8001 -p 8002:8002 \
  -v $(pwd)/model_repository:/models \
  nvcr.io/nvidia/tritonserver:24.xx-py3 \
  tritonserver --model-repository=/models

サーバー起動後、Pythonクライアントから推論リクエストを送信できます。

import tritonclient.http as httpclient
import numpy as np

client = httpclient.InferenceServerClient(url="localhost:8000")

inputs = [httpclient.InferInput("input", (4, 3, 224, 224), "FP32")]
inputs[0].set_data_from_numpy(np.random.randn(4, 3, 224, 224).astype(np.float32))

outputs = [httpclient.InferRequestedOutput("output")]

results = client.infer(model_name="resnet50_trt", inputs=inputs, outputs=outputs)
output_data = results.as_numpy("output")
print(f"Tritonからの応答 shape: {output_data.shape}")

トラブルシューティング

実践中に遭遇する可能性のある一般的な問題とその解決策です。

• ONNX変換エラー「Unsupported ONNX opset version」: TensorRTがサポートするONNX opsetバージョンは限られています。変換時にはopset_versionを下げて試してください（例: 17→15）。
• エンジンビルド時のメモリ不足: set_memory_pool_limitでワークスペースメモリを減らす（例: 1 << 30 = 1GB）。ただし、最適化の余地が減る可能性があります。
• INT8キャリブレーション後の精度大幅低下: キャリブレーション用データセットが実際の推論データの分布を代表していない可能性があります。実際の運用データに近い画像を数百枚以上使用してキャリブレーションを実行してください。
• Triton Serverがモデルをロードしない: config.pbtxtの設定（名前、プラットフォーム、ディメンション）がモデルと一致しているか、ディレクトリ構造が正確か確認してください。サーバーログ（docker logs <コンテナID>）を詳細に確認します。
• 動的バッチサイズが機能しない: エンジンビルド時にoptimization_profileで設定したmin, opt, maxの範囲内でリクエストしているか確認します。Tritonのconfig.pbtxtでもmax_batch_sizeが正しく設定されている必要があります。

まとめ

本記事では、PyTorchモデルをTensorRTを用いて本番環境向けに最適化し、Triton Inference Serverでサービス化するまでの完全な実践パイプラインを解説しました。ポイントをまとめます：

1. ONNX経由の変換は互換性の高い確実な方法です。onnx-simplifierの利用を習慣化しましょう。
2. エンジンビルド時は動的形状プロファイルを設定し、運用時の柔軟性を確保します。
3. 量子化（INT8/FP8）は推論性能向上の最も強力な手段の一つです。GPUアーキテクチャとモデルの特性に応じて選択します。
4. 本番デプロイにはTriton Inference Serverが不可欠です。モデル管理、バッチ処理、モニタリング、マルチモデル・マルチフレームワークのサポートにより、本番運用の負担を大幅に軽減します。

TensorRTは進化が速く、新しい最適化技術や機能が追加され続けています。本ガイドを出発点として、NVIDIAの公式ドキュメントや開発者ブログを参照し、最新のベストプラクティスを取り入れることをお勧めします。適切に最適化された推論パイプラインは、AIアプリケーションのコスト効率とユーザー体験を劇的に改善するでしょう。