What does this skill do, and when should you use it?
This skill brings object-detection models from Hugging Face or NVIDIA NGC into an NVIDIA DeepStream inference pipeline. It downloads ONNX files or exports SafeTensors, builds TensorRT engines, and configures a custom DeepStream bounding-box parser. It also runs single-stream and multi-stream benchmarks and produces Markdown, HTML, and PDF reports with charts. Its scope is limited to object-detection architectures.
Reads model files and config.json from Hugging Face or NGC, detects the available format, and downloads ONNX or exports SafeTensors; inspects ONNX shapes; builds dynamic TensorRT engines and benchmarks batch size 1 and the configured maximum batch size; creates DeepStream nvinfer configuration, a custom bbox parser, labels, and helper scripts; runs single-stream validation, KITTI detection dumping, multi-stream performance tests, and frame extraction; stores models, parsers, configs, logs, engines, samples, five charts, and Markdown, HTML, PDF, and JSON reports in the prescribed directory structure.
- An engineer needs to connect a Hugging Face object-detection model to DeepStream.
- A deployment team needs to convert an NVIDIA NGC detection model into a TensorRT engine.
- A developer needs to validate a custom DeepStream bbox parser and KITTI detections.
- A GPU inference team needs comparable BS=1, maximum-batch, single-stream, and multi-stream measurements.
- A team needs a charted DeepStream benchmark report in PDF form.
How do you install this skill?
- The skill autonomously performs network downloads, apt/pip installation, GPU engine builds, and extensive file writes; review commands, network access, and output paths in an isolated environment before use.
- Do not treat the BENCHMARK pass rates as execution evidence verified by this review; reproduce them separately on the target DeepStream and TensorRT versions.
- HuggingFace and NGC reachability may be constrained in mainland China, and the core acquisition flow provides no offline mirror or proxy strategy.
- Parser logic, preprocessing, TensorRT versions, and DeepStream configuration are highly model-specific; failures may require manual edits, while rollback is not fully specified.
- Shell / CLI
- Network access
- Local filesystem
NVIDIA DeepStream SDKTensorRT/trtexecNVIDIA GPU driversPython 3 virtual environmentoptimumPyTorchTransformersONNX RuntimematplotlibNumPymarkdownwkhtmltopdfmediainfodeepstream-appbc
Install the skill with the command documented in the repository README:
npx skills add nvidia/skills --skill deepstream-import-vision-model --yes
The source does not document a separate clone or manual-copy procedure for this skill.
tmp="$(mktemp -d)"
git clone --depth 1 https://github.com/NVIDIA/skills.git "$tmp"
mkdir -p ~/.claude/skills
cp -R "$tmp/skills/deepstream-import-vision-model" ~/.claude/skills/
rm -rf "$tmp"Generated from the source repository and skill path; it copies only this skill's folder. If the author's install steps above differ, follow those first. To scope it to one project, replace ~/.claude/skills with that project's .claude/skills.
How do you use this skill?
Ask a compatible agent to import an object-detection model from Hugging Face or NVIDIA NGC into NVIDIA DeepStream, build and validate the TensorRT and DeepStream pipeline, run benchmarks, and generate the reports. The environment should provide an NVIDIA GPU, drivers, TensorRT, and DeepStream. The default video is DeepStream's sample_720p.mp4 unless another path is explicitly supplied through DS_VIDEO.
What are this skill's strengths and limitations?
- Covers model acquisition, format conversion, TensorRT building, DeepStream configuration, validation, benchmarking, and reporting in one workflow.
- Uses fixed output directories and log filenames that the report tooling expects.
- Defines concrete gates and safeguards, including KITTI validation, dynamic engine naming, and zero-initialized detection objects.
- Provides a theoraenc+oggmux fallback when NVENC is unavailable, with a skip mode if the fallback components are absent.
- Supports object detection only; classification, segmentation, and other architectures are rejected.
- Requires an NVIDIA GPU, DeepStream SDK, TensorRT, and several system and Python tools; no CPU-only alternative is documented.
- The source provides no hardware, driver-version, or model compatibility matrix.
- The full workflow reads from Hugging Face or NGC and writes model artifacts, logs, samples, and reports to the filesystem.
How does this skill compare with similar options?
Side by side with related skills; every score comes from the same FSRS standard.
| Skill | FS score | Stars | Last updated | License |
|---|---|---|---|---|
| DeepStream Vision Model Importer this page ✓ NVIDIA · Official | 48 · Use with care | ★ 3.6k | 13d ago | Apache-2.0 |
| NVIDIA DeepStream Development ✓ NVIDIA · Official | 49 · Use with care | ★ 3.6k | 13d ago | Apache-2.0 |
| TAO Hugging Face Model Integrator ✓ NVIDIA · Official | 51 · Use with care | ★ 3.6k | 13d ago | Apache-2.0 |
| DeepStream Pipeline Builder ✓ NVIDIA · Official | 53 · Use with care | ★ 3.6k | 13d ago | Apache-2.0 |
| Azure AI Vision Image Analysis ✓ Microsoft · Official | 55 · Use with care | ★ 2.7k | 3mo ago | MIT |
How did FollowSkills review this skill?
The document clearly limits the target architecture, requires a shared virtual environment, prohibits certain encoders, and discloses HF_TOKEN, downloads, engine builds, and output paths. However, it mandates autonomous execution without stepwise confirmation and performs network downloads, apt/pip installation, and file creation without fully specifying data flow, permission boundaries, rollback, or sensitive-data handling, so points are deducted.
Phase references, fixed log contracts, validation gates, and failure messages are relatively detailed. However, the static material exposes brittle areas including lost pipeline exit codes, strict environment assumptions, model-specific manual adjustments, and many path/runtime dependencies. No key-path execution tests are statically verifiable, so the score is conservatively limited.
Object-detection scope, rejection rules for non-detection architectures, HF/NGC inputs, and main outputs are clear. However, the skill requires a narrow NVIDIA DeepStream/TensorRT/GPU environment, needs human judgment across model families, provides no Chinese-language support evidence, and does not address mainland-China reachability of HuggingFace/NGC, so points are deducted.
Directory structure, phase references, script inventory, version 1.2.2, and CC-BY-4.0 plus Apache-2.0 licensing are documented, and the organization is generally readable. However, the recommended Instructions and Examples sections are missing, the benchmark flags the author format as nonconforming, and no explicit changelog, maintenance owner, or update path is provided, so points are deducted.
The intended result covers model acquisition, ONNX/TensorRT conversion, DeepStream validation, benchmarking, and three report formats, with a directly usable output layout in principle. However, success depends on an unverified GPU software stack, model-specific parser work, and manual corrections. The BENCHMARK results are submitted claims and cannot prove general usability in this static review, so points are deducted.
The source provides fixed paths, log contracts, formulas, evaluation tasks, and revision metadata, giving useful audit clues. However, there is no statically confirmable CI, committed key-path test suite, or independently reproducible experiment. The BENCHMARK execution results are claims contained in the files, not independently verified evidence, so points are deducted.
Open a dimension to read why it scored that way
Evidence confidence：Low — Mostly static review, author material or a limited demo; useful for discovery, not high-risk decisions.
See the full review method →