Yolo Nas Pose Tensorrt

Yolo Nas Pose Tensorrt is the workhorse of this two-node pack: feed it a batch of images plus a TensorRT engine, and it returns OpenPose-style skeleton maps fast enough that pose estimation stops being the bottleneck. This is the node that replaces the slow DWPose/OpenPose preprocessor in a ControlNet workflow - the README calls the ControlNet hookup "experimental," but it's the whole point.

What it actually does

Given a batch of images, it resizes each to 640×640, runs the YOLO-NAS-POSE engine on every frame, and draws the detected person's skeleton on a black background - 17 COCO keypoints plus an interpolated neck point, colored in the usual OpenPose palette. Then it stretches the result back to your input resolution. That's the exact kind of conditioning image an OpenPose ControlNet expects, which is why it slots in so cleanly.

The speed is the reason it exists. The README benchmarks the same large model this pack ships at 105–115 FPS on an H100 - the author's whole pack family exists to get pose/upscale off the CPU and onto TensorRT. Where people really feel it is video: the community's standard complaint about DWPose in the aux pack is that a video can take fifteen minutes to pose-extract, and a TensorRT-compiled detector turns that into something you barely notice. If you've got a batch of frames from a video loader and you need pose conditioning per frame, this is the one you reach for.

The inputs and output

• images - an IMAGE tensor, any batch size. The node iterates frames with a progress bar, so a whole video clip works in one pass.
• engine - a dropdown populated from ComfyUI/models/tensorrt/yolo-nas-pose/. This is where the pack's other node, Yolo Nas Pose Engine Builder, comes in: build an engine there first, refresh the page, and it appears here.

The output is a single IMAGE: the drawn skeleton maps, one per input frame, resized back to your original dimensions. Wire it straight into an OpenPose ControlNet's image input. You can skip the openpose preprocessor entirely - this node already is the preprocessor, which is the whole trick.

Installing and getting an engine in that dropdown

Install the pack via ComfyUI Manager (search ComfyUI YoloNasPose Tensorrt) or:

cd ComfyUI/custom_nodes
git clone https://github.com/yuvraj108c/ComfyUI-YoloNasPose-Tensorrt
cd ComfyUI-YoloNasPose-Tensorrt
pip install -r requirements.txt

The heavy requirement is tensorrt - the wheel must match your CUDA/driver setup, and the README only claims Ubuntu 22.04, CUDA 12.4, TRT 10.x, H100. Windows is untested by the author. The most common failure across his packs is No module named 'tensorrt' on Windows portable installs, which usually means the dependency went into the wrong Python environment - let Manager install it, or run pip inside the exact venv ComfyUI uses.

Troubleshooting

• Empty engine dropdown - you haven't built an engine yet, or it's not in models/tensorrt/yolo-nas-pose/. Run the Engine Builder node first.
• Engine from another GPU - TensorRT engines are compiled per GPU architecture. If you copied an engine from a friend's build, it won't load. Build your own on the machine that runs it.
• Black frames in the output - the node catches per-frame inference errors and silently returns a black frame rather than crashing your graph. If you see black output, check the console: it's usually an engine/dtype mismatch, and the fix is usually rebuilding with FP16 off (the Engine Builder's use_fp16 toggle exists precisely for that).
• Wonky poses - that's not the engine, that's the confidence threshold baked into the model. Rebuild with a different threshold (0.5 is the sane middle ground) or feed cleaner frames.

Keep your pose pass downstream of the sampler's ControlNet conditioning (weight ~0.9 for modern union models, looser if you want flexibility), and you've got a genuinely fast pose-pipeline.